public async Task AddConversation(Conversation conversation)
{
try
{
var senderUsername = "******" + conversation.Participants[0];
var receiverUsername = "******" + conversation.Participants[1];
var senderEntity = ToEntity(senderUsername, conversation);
var receiverEntity = ToEntity(receiverUsername, conversation);
try
{
await _documentClient.CreateDocumentAsync(DocumentCollectionUri, senderEntity);
}
catch (DocumentClientException e)
{
if (e.StatusCode != HttpStatusCode.Conflict)
{
throw new StorageErrorException($"Failed to create conversation {conversation.Id}",
e, (int)e.StatusCode);
}
}
await _documentClient.CreateDocumentAsync(DocumentCollectionUri, receiverEntity);
}
catch (DocumentClientException e)
{
if (e.StatusCode == HttpStatusCode.Conflict)
{
throw new ConversationAlreadyExistsException($"Conversation {conversation.Id} already exists");
}
throw new StorageErrorException($"Failed to create conversation {conversation.Id}",
e, (int)e.StatusCode);
}
}
/// <summary>
/// Creates a document and its parent containers (database, collection) if they do not exist.
/// </summary>
/// <param name="dbId">Database id.</param>
/// <param name="collectionId">Collection id.</param>
/// <param name="document">Object to create.</param>
/// <param name="partitionKeyField">Request options</param>
/// <param name="requestOptions">Request options</param>
/// <param name="disableIdGeneration">Disables automatic id generation</param>
/// <returns>Created document</returns>
public async Task <ResourceResponse <Document> > CreateDocumentAndContainersAsync(
string dbId,
string collectionId,
object document,
string partitionKeyField,
RequestOptions requestOptions = null,
bool disableIdGeneration = false)
{
Code.ExpectsNotNullOrWhiteSpaceArgument(dbId, nameof(dbId), TaggingUtilities.ReserveTag(0x2381b161 /* tag_961f7 */));
Code.ExpectsNotNullOrWhiteSpaceArgument(collectionId, nameof(collectionId), 0);
Code.ExpectsArgument(document, nameof(document), TaggingUtilities.ReserveTag(0x2381b162 /* tag_961f8 */));
Uri collectionUri = UriFactory.CreateDocumentCollectionUri(dbId, collectionId);
IDocumentClient client = await GetDocumentClientAsync().ConfigureAwait(false);
return(await DocumentDbAdapter.ExecuteAndLogAsync(TaggingUtilities.ReserveTag(0x2381b163 /* tag_961f9 */),
async() =>
{
try
{
return await client.CreateDocumentAsync(collectionUri, document, requestOptions, disableIdGeneration).ConfigureAwait(false);
}
catch (DocumentClientException e) when(e.StatusCode == HttpStatusCode.NotFound)
{
// We get NotFound exception either when db and/or collection is not yet created. We create the missing component before retrying to create the document.
await GetOrCreateDbAndCollectionAsync(dbId, collectionId, partitionKeyField).ConfigureAwait(false);
return await client.CreateDocumentAsync(collectionUri, document, requestOptions, disableIdGeneration).ConfigureAwait(false);
}
}).ConfigureAwait(false));
}
/// <summary>
/// Insert entity to database even though collection for this entity wasn't created yet.
/// </summary>
/// <typeparam name="T">Type of entity to insert</typeparam>
/// <param name="entity">Entity to insert</param>
public async Task <bool> InsertAsync <T>(T entity, string collectionName) where T : IBaseEntity
{
await GetDBClient();
await _documentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(cosmosDBName),
new DocumentCollection { Id = typeof(T).Name });
var result = await _documentClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(cosmosDBName, collectionName), entity);
return(result.StatusCode == System.Net.HttpStatusCode.Created);
}
public async Task GivenACreateRequest_WithSessionConsistency_ThenTheResponseHeadersContainTheSessionToken()
{
_innerClient
.CreateDocumentAsync("coll", (1, 2), Arg.Is <RequestOptions>(o => o.ConsistencyLevel == ConsistencyLevel.Session && o.SessionToken == "1"))
.Returns(CosmosDbMockingHelper.CreateResourceResponse(new Document(), HttpStatusCode.OK, new NameValueCollection {
{ CosmosDbHeaders.SessionToken, "2" }
}));
_requestHeaders.Add(CosmosDbHeaders.ConsistencyLevel, "Session");
_requestHeaders.Add(CosmosDbHeaders.SessionToken, "1");
await _fhirClient.CreateDocumentAsync("coll", (1, 2));
await _cosmosResponseProcessor.Received(1).ProcessResponse(Arg.Any <ResourceResponseBase>());
}
public async Task <TModel> CreateItemAsync(TModel item)
{
var documentUri = UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId);
var resourceResponse = await documentClient.CreateDocumentAsync(documentUri, item);
return((TModel)((dynamic)resourceResponse.Resource));
}
private static void InsertSession(IDocumentClient client)
{
//Create some data to store
var session = CreateSession();
client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName), session).GetAwaiter().GetResult();
}
public async Task <int> AddAsync <TDocument>(TDocument[] documents,
CancellationToken cancellationToken = default
)
where TDocument : EventStoreDocument
{
await ExecuteAsync(async dbCol =>
{
foreach (var doc in documents)
{
await _client.CreateDocumentAsync(dbCol.DocumentCollectionUri,
doc,
new RequestOptions
{
PartitionKey = new PartitionKey(doc.StreamId),
JsonSerializerSettings = _jsonSettings
},
true,
cancellationToken
);
}
},
cancellationToken : cancellationToken
);
return(documents.Length);
}
public async Task CreateDocumentAsync <T>(T document)
{
await _client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(
_databaseId,
typeof(T).Name),
document);
}
private static async Task <bool> CheckList(IDocumentClient client, string link)
{
var CreateDatabase = Environment.GetEnvironmentVariable("CreateDatabase");
if (CreateDatabase != null && CreateDatabase == "true")
{
var databaseDefinition = new Database {
Id = DatabaseId
};
await client.CreateDatabaseIfNotExistsAsync(databaseDefinition);
var collectionDefinition = new DocumentCollection {
Id = CollectionId
};
await client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DatabaseId),
collectionDefinition);
}
var response = client.CreateDocumentQuery <Item>(UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId), $"select * from c WHERE c.Url='{link}'").ToList();
if (response.Count > 0)
{
return(true);
}
await client.CreateDocumentAsync(
UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId),
new Item()
{
Url = link
});
return(false);
}
public async Task <ResourceResponse <Document> > LoadNoReplace(
IAmDocument doc)
{
ResourceResponse <Document> r;
try
{
r = await client.ReadDocumentAsync(
UriFactory.CreateDocumentUri(
databaseId,
collectionId,
doc.Id),
new RequestOptions {
PartitionKey = new PartitionKey(doc.PartitionKey)
});
}
catch (DocumentClientException de)
{
if (de.StatusCode == HttpStatusCode.NotFound)
{
r = await client.CreateDocumentAsync(
UriFactory.CreateDocumentCollectionUri(
databaseId,
collectionId),
doc);
}
else
{
throw;
}
}
return(r);
}
public async Task <TEntity> CreateAsync <TEntity>(TEntity entity, Domain.RequestOptions options = null) where TEntity : class
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (_databaseName == null)
{
throw new DataStoreException("Connect must be called to update CosmosDB");
}
try
{
var response = await _client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(_databaseName, _collectionName), entity, options.ToRequestOptions(), true, _cancellationToken);
if (response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Created)
{
return(entity);
}
throw new DocumentUpdateException("Unable to create product. Invalid status returned from CosmosDB.");
}
catch (DocumentClientException e)
{
if (e.StatusCode == HttpStatusCode.NotFound)
{
throw new DocumentUpdateException("Unable to create product. Invalid status returned from CosmosDB.");
}
throw;
}
}
public async Task Put(T value)
{
if (Get(value) == null)
{
await _documentClient.CreateDocumentAsync(GetUri(), ValueObjectDocument <T> .Create(_valueType, value));
}
}
public async Task <TModel> CreateItemAsync(TModel item)
{
var documentUri = UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId);
var model = await documentClient.CreateDocumentAsync(documentUri, item);
return(model as TModel);
}
//public async Task<IActionResult> Post([FromBody] Worker item)
public async Task <System.Net.HttpStatusCode> Post([FromBody] Worker item)
{
var response = await _documentClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(databaseId, collectionId), item);
return(response.StatusCode);
//return Ok();
}
public virtual async Task <TDocument> Create(TDocument document)
{
return((TDocument)(dynamic)(await _documentClient.CreateDocumentAsync(
await _collectionProvider.GetCollectionDocumentsLink(),
document))
.Resource);
}
public async Task <IActionResult> Post([FromBody] Item item)
{
//we can add a try catch block or return a response from this block
var response = await _documentClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(databaseId, collectionId), item);
return(Ok());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest request,
[CosmosDB(ConnectionStringSetting = "DBConnectionString")] IDocumentClient client,
ILogger log)
{
log.LogInformation("UpdateTokenFunction - Invoked");
TokenStatusEnume status;
Token token = new Token();
Enum.TryParse(request.Query["status"], out status);
string tokenNo = request.Query["tokenNo"];
Uri tokenCollectUri = UriFactory.CreateDocumentCollectionUri("TokenManagerDB", "Token");
var options = new FeedOptions {
MaxItemCount = 1, EnableCrossPartitionQuery = true
};
IDocumentQuery <Token> queryRes = client.CreateDocumentQuery <Token>(tokenCollectUri, options)
.Where(token => token.TokenNo == tokenNo)
.AsDocumentQuery();
if (queryRes.HasMoreResults)
{
token = (Token)queryRes.ExecuteNextAsync().Result.First();
token.Status = status;
token.CurrentEstimatedWaitingTime = 0;
await client.CreateDocumentAsync(tokenCollectUri, token);
}
log.LogInformation("UpdateTokenFunction - Completed");
return(new OkObjectResult(token));
}
public static async Task <ResourceResponse <Document> > HandleEntityFeedInsertAsync(string tableName, IDocumentClient client, Document document, RequestOptions requestOptions, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
Uri uri = UriFactory.CreateDocumentCollectionUri("TablesDB", tableName);
return(await client.CreateDocumentAsync(uri.ToString(), document, requestOptions, disableAutomaticIdGeneration : true));
}
public async Task GivenACreateRequest_WithSessionConsistency_ThenTheResponseHeadersContainTheSessionToken()
{
_innerClient
.CreateDocumentAsync("coll", (1, 2), Arg.Is <RequestOptions>(o => o.ConsistencyLevel == ConsistencyLevel.Session && o.SessionToken == "1"))
.Returns(CreateResourceResponse(new Document(), HttpStatusCode.OK, new NameValueCollection {
{ CosmosDbHeaders.SessionToken, "2" }
}));
_requestHeaders.Add(CosmosDbHeaders.ConsistencyLevel, "Session");
_requestHeaders.Add(CosmosDbHeaders.SessionToken, "1");
await _fhirClient.CreateDocumentAsync("coll", (1, 2));
Assert.True(_responseHeaders.TryGetValue(CosmosDbHeaders.SessionToken, out var values));
Assert.Equal("2", values.ToString());
}
public async Task <Document> CreateDocumentAsync(object document, RequestOptions options = null,
bool disableAutomaticIdGeneration = false, CancellationToken cancellationToken = default(CancellationToken))
{
var uri = UriFactory.CreateDocumentCollectionUri(_databaseName, _collectionName);
return(await _documentClient.CreateDocumentAsync(uri, document, options, disableAutomaticIdGeneration, cancellationToken));
}
public async Task <ExportJobOutcome> CreateExportJobAsync(ExportJobRecord jobRecord, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(jobRecord, nameof(jobRecord));
var cosmosExportJob = new CosmosExportJobRecordWrapper(jobRecord);
try
{
ResourceResponse <Document> result = await _documentClient.CreateDocumentAsync(
_collectionUri,
cosmosExportJob,
new RequestOptions()
{
PartitionKey = new PartitionKey(CosmosDbExportConstants.ExportJobPartitionKey)
},
disableAutomaticIdGeneration : true,
cancellationToken : cancellationToken);
return(new ExportJobOutcome(jobRecord, WeakETag.FromVersionId(result.Resource.ETag)));
}
catch (DocumentClientException dce)
{
if (dce.StatusCode == HttpStatusCode.RequestEntityTooLarge)
{
throw new RequestRateExceededException(dce.RetryAfter);
}
_logger.LogError(dce, "Unhandled Document Client Exception");
throw;
}
}
public async Task <T> CreateAsync(T item)
{
var collectionUri = UriFactory.CreateDocumentCollectionUri(_databaseId, _collectionId);
var result = await _client.CreateDocumentAsync(collectionUri, item).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <T>(result.Resource.ToString()));
}
private async Task StoreConfigRecordAsync(
IDocumentClient client,
DocumentDbConfig dbConfig,
ServiceConfigRecord newRecord,
Document existingDocument)
{
var collectionUri = GetDocumentCollectionUri(dbConfig);
if (existingDocument == null)
{
// No record exists yet. Use the creation method to ensure failure if another process has modified the
// record that a failure is produced.
await client.CreateDocumentAsync(collectionUri, newRecord);
}
else
{
// Add IfMatch header to ensure the record has not been changed by another process.
RequestOptions options = new RequestOptions
{
AccessCondition = new AccessCondition
{
Condition = existingDocument.ETag,
Type = AccessConditionType.IfMatch
}
};
await client.UpsertDocumentAsync(collectionUri, newRecord, options);
}
}
public async Task <Map> Create(Map map)
{
var mapDocument = new MapDocument
{
Id = map.Id,
Nodes = map.Nodes.Values.Select(ToNodeDocument),
Edges = map.Nodes.Values.SelectMany(ToEdgeDocuments)
};
var collectionUri = UriFactory.CreateDocumentCollectionUri(_databaseId, CollectionId);
try
{
await _documentClient.CreateDocumentAsync(collectionUri, mapDocument);
}
catch (DocumentClientException dce)
{
if (dce.Error.Code == "Conflict")
{
return(null); // map with the same ID already exists
}
throw;
}
return(map);
}
public async Task <string> CreateTodoAsync(Todo todo)
{
var document = await documentClient.CreateDocumentAsync(
UriFactory.CreateDocumentCollectionUri(dbName, collectionName),
todo);
return(document.Resource.Id);
}
public async Task <T> CreateItem(T item)
{
item.CreatedUtc = DateTime.UtcNow;
var document = await _client.CreateDocumentAsync(_collectionUri, item);
return((T)(dynamic)document.Resource);
}
/// <inheritdoc/>
public async Task <T> CreateAsync <T>(T item)
{
Document document = await _documentClient.CreateDocumentAsync(_collectionUri, item);
T obj = (dynamic)document;
return(obj);
}
public async Task <TModel> CreateItemAsync(TKey partitionKey, TModel item)
{
var documentUri = UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId);
var resourceResponse = await documentClient.CreateDocumentAsync(documentUri, item, BuildRequestOptions(partitionKey));
logger.LogDebug($"Create cost (in RU/s) : {resourceResponse.RequestCharge}");
return((TModel)((dynamic)resourceResponse.Resource));
}
public async Task <DataResult <string> > CreateNewItem(T item)
{
var response = await _documentClient.CreateDocumentAsync(_documentCollectionUri, item);
var isSuccessful = response.StatusCode == HttpStatusCode.Created;
return(new DataResult <string>(isSuccessful, response.ActivityId));
}
public async Task <IResourceResponse <Document> > CreateAsync(
IDocumentClient client,
StorageConfig cfg,
Resource resource)
{
var collectionLink = $"/dbs/{cfg.DocumentDbDatabase}/colls/{cfg.DocumentDbCollection}";
return(await client.CreateDocumentAsync(collectionLink, resource));
}
private static void InsertSession(IDocumentClient client)
{
//Create some data to store
var session = CreateSession();
client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName), session).GetAwaiter().GetResult();
}