private static async Task UpsertItemAsync()
{
Console.WriteLine("\n1.6 - Upserting a item");
SalesOrder upsertOrder = GetSalesOrderSample("SalesOrder3");
CosmosItemResponse <SalesOrder> response = await container.Items.UpsertItemAsync(
partitionKey : upsertOrder.AccountNumber,
item : upsertOrder);
SalesOrder upserted = response.Resource;
Console.WriteLine($"Request charge of upsert operation: {response.RequestCharge}");
Console.WriteLine($"StatusCode of this operation: { response.StatusCode}");
Console.WriteLine($"Id of upserted item: {upserted.Id}");
Console.WriteLine($"AccountNumber of upserted item: {upserted.AccountNumber}");
upserted.AccountNumber = "updated account number";
response = await container.Items.UpsertItemAsync(partitionKey : upserted.AccountNumber, item : upserted);
upserted = response.Resource;
Console.WriteLine($"Request charge of upsert operation: {response.RequestCharge}");
Console.WriteLine($"StatusCode of this operation: { response.StatusCode}");
Console.WriteLine($"Id of upserted item: {upserted.Id}");
Console.WriteLine($"AccountNumber of upserted item: {upserted.AccountNumber}");
}
/// <summary>
/// The function demonstrates the Item CRUD operation using the NonePartitionKeyValue
/// NonePartitionKeyValue represents the information that the current item doesn't have a value for partitition key
/// All items inserted pre-migration are grouped into this logical partition and can be accessed by providing this value
/// for the partitionKey parameter
/// New item CRUD could be performed using this NonePartitionKeyValue to target the same logical partition
/// </summary>
private static async Task ItemOperationsWithNonePartitionKeyValue(CosmosContainer container)
{
string itemid = Guid.NewGuid().ToString();
DeviceInformationItem itemWithoutPK = GetDeviceWithNoPartitionKey(itemid);
// Insert a new item with NonePartitionKeyValue
CosmosItemResponse <DeviceInformationItem> createResponse = await container.Items.CreateItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
item : itemWithoutPK);
Console.WriteLine("Creating Item {0} Status Code {1}", itemid, createResponse.StatusCode);
// Read an existing item with NonePartitionKeyValue
CosmosItemResponse <DeviceInformationItem> readResponse = await container.Items.ReadItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemid);
Console.WriteLine("Reading Item {0} Status Code {1}", itemid, readResponse.StatusCode);
// Replace the content of existing item with NonePartitionKeyValue
itemWithoutPK.DeviceId = Guid.NewGuid().ToString();
CosmosItemResponse <DeviceInformationItem> replaceResponse = await container.Items.ReplaceItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemWithoutPK.Id,
item : itemWithoutPK);
Console.WriteLine("Replacing Item {0} Status Code {1}", itemid, replaceResponse.StatusCode);
// Delete an item with NonePartitionKeyValue.
CosmosItemResponse <DeviceInformationItem> deleteResponse = await container.Items.DeleteItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemid);
Console.WriteLine("Deleting Item {0} Status Code {1}", itemid, deleteResponse.StatusCode);
}
/// <summary>
/// Runs a simple script which just does a server side query
/// </summary>
private static async Task RunSimpleScript(CosmosContainer container)
{
// 1. Create stored procedure for script.
string scriptFileName = @"js\SimpleScript.js";
string scriptId = Path.GetFileNameWithoutExtension(scriptFileName);
await TryDeleteStoredProcedure(container, scriptId);
CosmosStoredProcedure sproc = await container.StoredProcedures.CreateStoredProceducreAsync(scriptId, File.ReadAllText(scriptFileName));
// 2. Create a document.
SampleDocument doc = new SampleDocument
{
Id = Guid.NewGuid().ToString(),
LastName = "Estel",
Headquarters = "Russia",
Locations = new Location[] { new Location {
Country = "Russia", City = "Novosibirsk"
} },
Income = 50000
};
CosmosItemResponse <SampleDocument> created = await container.Items.CreateItemAsync(doc.LastName, doc);
// 3. Run the script. Pass "Hello, " as parameter.
// The script will take the 1st document and echo: Hello, <document as json>.
CosmosItemResponse <string> response = await container.StoredProcedures[scriptId].ExecuteAsync <string, string>(doc.LastName, "Hello");
Console.WriteLine("Result from script: {0}\r\n", response.Resource);
await container.Items.DeleteItemAsync <SampleDocument>(doc.LastName, doc.Id);
}
private static async Task ReadItemAsync()
{
Console.WriteLine("\n1.2 - Reading Item by Id");
// Note that Reads require a partition key to be specified.
CosmosItemResponse <SalesOrder> response = await container.Items.ReadItemAsync <SalesOrder>(
partitionKey : "Account1",
id : "SalesOrder1");
// You can measure the throughput consumed by any operation by inspecting the RequestCharge property
Console.WriteLine("Item read by Id {0}", response.Resource);
Console.WriteLine("Request Units Charge for reading a Item by Id {0}", response.RequestCharge);
SalesOrder readOrder = (SalesOrder)response;
// Read the same item but as a stream.
using (CosmosResponseMessage responseMessage = await container.Items.ReadItemStreamAsync(
partitionKey: "Account1",
id: "SalesOrder1"))
{
// Item stream operations do not throw exceptions for better performance
if (responseMessage.IsSuccessStatusCode)
{
SalesOrder streamResponse = FromStream <SalesOrder>(responseMessage.Content);
Console.WriteLine($"\n1.2.2 - Item created {streamResponse.Id}");
}
else
{
Console.WriteLine($"Read item from stream failed. Status code: {responseMessage.StatusCode} Message: {responseMessage.ErrorMessage}");
}
}
}
public async Task CreateDropPointTest()
{
SpatialItem spatialItem = new SpatialItem
{
Name = spatialName,
partitionKey = Guid.NewGuid().ToString(),
id = Guid.NewGuid().ToString(),
point = GetPoint(),
};
CosmosItemResponse <SpatialItem> createResponse = await this.Container.Items.CreateItemAsync <SpatialItem>(partitionKey : spatialItem.partitionKey, item : spatialItem);
Assert.IsNotNull(createResponse);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
CosmosItemResponse <SpatialItem> readResponse = await this.Container.Items.ReadItemAsync <SpatialItem>(partitionKey : spatialItem.partitionKey, id : spatialItem.id);
Assert.IsNotNull(readResponse);
Assert.AreEqual(HttpStatusCode.OK, readResponse.StatusCode);
Assert.IsNotNull(readResponse.Resource.point);
CosmosItemResponse <SpatialItem> deleteResponse = await this.Container.Items.DeleteItemAsync <SpatialItem>(partitionKey : spatialItem.partitionKey, id : spatialItem.id);
Assert.IsNotNull(deleteResponse);
Assert.AreEqual(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
public async Task ValidateCurrentWriteQuorumAndReplicaSetHeader()
{
CosmosClient client = TestCommon.CreateCosmosClient(false);
CosmosDatabase db = null;
try
{
db = await client.Databases.CreateDatabaseAsync(Guid.NewGuid().ToString());
PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition {
Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash
};
CosmosContainerSettings containerSetting = new CosmosContainerSettings()
{
Id = Guid.NewGuid().ToString(),
PartitionKey = partitionKeyDefinition
};
CosmosContainer coll = await db.Containers.CreateContainerAsync(containerSetting);
Document documentDefinition = new Document {
Id = Guid.NewGuid().ToString()
};
CosmosItemResponse <Document> docResult = await coll.Items.CreateItemAsync <Document>(documentDefinition.Id, documentDefinition);
Assert.IsTrue(int.Parse(docResult.Headers[WFConstants.BackendHeaders.CurrentWriteQuorum], CultureInfo.InvariantCulture) > 0);
Assert.IsTrue(int.Parse(docResult.Headers[WFConstants.BackendHeaders.CurrentReplicaSetSize], CultureInfo.InvariantCulture) > 0);
}
finally
{
await db.DeleteAsync();
}
}
public async Task <T> GetAsync(string partitionKey, string id)
{
CosmosItemResponse <T> response = await Container.Items.ReadItemAsync <T>(partitionKey, id);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(default(T));
}
return((T)response);
}
private static async Task DeleteItemAsync()
{
Console.WriteLine("\n1.7 - Deleting a item");
CosmosItemResponse <SalesOrder> response = await container.Items.DeleteItemAsync <SalesOrder>(
partitionKey : "Account1",
id : "SalesOrder3");
Console.WriteLine("Request charge of delete operation: {0}", response.RequestCharge);
Console.WriteLine("StatusCode of operation: {0}", response.StatusCode);
}
/*
* Delete an item in the container
*/
private async Task DeleteFamilyItem()
{
var partitionKeyValue = "Wakefield";
var familyId = "Wakefield.7";
// Delete an item. Note we must provide the partition key value and id of the item to delete
CosmosItemResponse <Family> wakefieldFamilyResponse = await this.container.Items.DeleteItemAsync <Family>(partitionKeyValue, familyId);
Console.WriteLine("Deleted Family [{0},{1}]\n", partitionKeyValue, familyId);
}
private static async Task UseConsistencyLevels()
{
// Override the consistency level for a read request
CosmosItemResponse <SalesOrder> response = await container.Items.ReadItemAsync <SalesOrder>(
partitionKey : "Account2",
id : "SalesOrder2",
requestOptions : new CosmosItemRequestOptions()
{
ConsistencyLevel = ConsistencyLevel.Eventual
});
}
public async Task CreateDropItemTest()
{
ToDoActivity testItem = this.CreateRandomToDoActivity();
CosmosItemResponse <ToDoActivity> response = await this.Container.Items.CreateItemAsync <ToDoActivity>(partitionKey : testItem.status, item : testItem);
Assert.IsNotNull(response);
Assert.IsNotNull(response.MaxResourceQuota);
Assert.IsNotNull(response.CurrentResourceQuotaUsage);
CosmosItemResponse <ToDoActivity> deleteResponse = await this.Container.Items.DeleteItemAsync <ToDoActivity>(partitionKey : testItem.status, id : testItem.id);
Assert.IsNotNull(deleteResponse);
}
/// <summary>
/// The function demonstrates migrating documents that were inserted without a value for partition key, and those inserted
/// pre-migration to other logical partitions, those with a value for partition key.
/// </summary>
private static async Task MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue(CosmosContainer container)
{
// Pre-create a few items in the container to demo the migration
const int ItemsToCreate = 4;
// Insert a few items with no Partition Key
for (int i = 0; i < ItemsToCreate; i++)
{
string itemid = Guid.NewGuid().ToString();
DeviceInformationItem itemWithoutPK = GetDeviceWithNoPartitionKey(itemid);
CosmosItemResponse <DeviceInformationItem> createResponse = await container.Items.CreateItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
item : itemWithoutPK);
}
// Query items on the container that have no partition key value by supplying NonePartitionKeyValue
// The operation is made in batches to not lose work in case of partial execution
int resultsFetched = 0;
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
CosmosResultSetIterator <DeviceInformationItem> setIterator = container.Items
.CreateItemQuery <DeviceInformationItem>(sql, partitionKey: CosmosContainerSettings.NonePartitionKeyValue, maxItemCount: 2);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <DeviceInformationItem> queryResponse = await setIterator.FetchNextSetAsync();
resultsFetched += queryResponse.Count();
// For the items returned with NonePartitionKeyValue
IEnumerator <DeviceInformationItem> iter = queryResponse.GetEnumerator();
while (iter.MoveNext())
{
DeviceInformationItem item = iter.Current;
if (item.DeviceId != null)
{
// Using existing deviceID for partition key
item.PartitionKey = item.DeviceId;
Console.WriteLine("Migrating item {0} to Partition {1}", item.Id, item.DeviceId);
// Re-Insert into container with a partition key
// This could result in exception if the same item was inserted in a previous run of the program on existing container
// and the program stopped before the delete.
CosmosItemResponse <DeviceInformationItem> createResponseWithPk = await container.Items.CreateItemAsync <DeviceInformationItem>(
partitionKey : item.PartitionKey,
item : item);
// Deleting item from fixed container with CosmosContainerSettings.NonePartitionKeyValue.
CosmosItemResponse <DeviceInformationItem> deleteResponseWithoutPk = await container.Items.DeleteItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : item.Id);
}
}
}
}
/// <summary>
/// 2. Basic CRUD operations using dynamics instead of strongly typed objects
/// Cosmos does not require objects to be typed. Applications that merge data from different data sources, or
/// need to handle evolving schemas can write data directly as JSON or dynamic objects.
/// </summary>
private static async Task RunBasicOperationsOnDynamicObjects()
{
Console.WriteLine("\n2. Use Dynamics");
// Create a dynamic object
dynamic salesOrder = new
{
id = "_SalesOrder5",
AccountNumber = "NewUser01",
PurchaseOrderNumber = "PO18009186470",
OrderDate = DateTime.UtcNow,
Total = 5.95,
};
Console.WriteLine("\nCreating item");
CosmosItemResponse <dynamic> response = await container.Items.CreateItemAsync <dynamic>("NewUser01", salesOrder);
dynamic createdItem = response.Resource;
Console.WriteLine("Item with id {0} created", createdItem.Id);
Console.WriteLine("Request charge of operation: {0}", response.RequestCharge);
response = await container.Items.ReadItemAsync <dynamic>(partitionKey : "NewUser01", id : "_SalesOrder5");
dynamic readItem = response.Resource;
//update a dynamic object by just creating a new Property on the fly
//Item is itself a dynamic object, so you can just use this directly too if you prefer
readItem.Add("shippedDate", DateTime.UtcNow);
//if you wish to work with a dynamic object so you don't need to use SetPropertyValue() or GetPropertyValue<T>()
//then you can cast to a dynamic
salesOrder = readItem;
salesOrder.foo = "bar";
//now do a replace using this dynamic item
//everything that is needed is contained in the readDynOrder object
//it has a .self Property
Console.WriteLine("\nReplacing item");
response = await container.Items.ReplaceItemAsync <dynamic>(partitionKey : "NewUser01", id : "_SalesOrder5", item : salesOrder);
dynamic replaced = response.Resource;
Console.WriteLine("Request charge of operation: {0}", response.RequestCharge);
Console.WriteLine("shippedDate: {0} and foo: {1} of replaced item", replaced.shippedDate, replaced.foo);
}
private static async Task UpsertItemAsync()
{
Console.WriteLine("\n1.6 - Upserting a item");
SalesOrder upsertOrder = GetSalesOrderSample("SalesOrder3");
CosmosItemResponse <SalesOrder> response = await container.Items.UpsertItemAsync(
partitionKey : upsertOrder.AccountNumber,
item : upsertOrder);
SalesOrder upserted = response.Resource;
Console.WriteLine($"Request charge of upsert operation: {response.RequestCharge}");
Console.WriteLine($"StatusCode of this operation: { response.StatusCode}");
Console.WriteLine($"Id of upserted item: {upserted.Id}");
Console.WriteLine($"AccountNumber of upserted item: {upserted.AccountNumber}");
upserted.AccountNumber = "updated account number";
response = await container.Items.UpsertItemAsync(partitionKey : upserted.AccountNumber, item : upserted);
upserted = response.Resource;
Console.WriteLine($"Request charge of upsert operation: {response.RequestCharge}");
Console.WriteLine($"StatusCode of this operation: { response.StatusCode}");
Console.WriteLine($"Id of upserted item: {upserted.Id}");
Console.WriteLine($"AccountNumber of upserted item: {upserted.AccountNumber}");
// For better performance upsert a SalesOrder object from a stream.
SalesOrder salesOrderV4 = GetSalesOrderSample("SalesOrder4");
using (Stream stream = Program.ToStream <SalesOrder>(salesOrderV4))
{
using (CosmosResponseMessage responseMessage = await container.Items.UpsertItemStreamAsync(
partitionKey: salesOrderV4.AccountNumber,
streamPayload: stream))
{
// Item stream operations do not throw exceptions for better performance
if (responseMessage.IsSuccessStatusCode)
{
SalesOrder streamResponse = FromStream <SalesOrder>(responseMessage.Content);
Console.WriteLine($"\n1.6.2 - Item upserted via stream {streamResponse.Id}");
}
else
{
Console.WriteLine($"Upsert item from stream failed. Status code: {responseMessage.StatusCode} Message: {responseMessage.ErrorMessage}");
}
}
}
}
/*
* Update an item in the container
*/
private async Task ReplaceFamilyItem()
{
CosmosItemResponse <Family> wakefieldFamilyResponse = await this.container.Items.ReadItemAsync <Family>("Wakefield", "Wakefield.7");
var itemBody = wakefieldFamilyResponse.Resource;
// update registration status from false to true
itemBody.IsRegistered = true;
// update grade of child
itemBody.Children[0].Grade = 6;
// replace the item with the updated content
wakefieldFamilyResponse = await this.container.Items.ReplaceItemAsync <Family>(itemBody.LastName, itemBody.Id, itemBody);
Console.WriteLine("Updated Family [{0},{1}]\n. Body is now: {2}\n", itemBody.LastName, itemBody.Id, wakefieldFamilyResponse.Resource);
}
private static async Task ReadItemAsync()
{
Console.WriteLine("\n1.2 - Reading Item by Id");
// Note that Reads require a partition key to be specified. This can be skipped if your collection is not
// partitioned i.e. does not have a partition key definition during creation.
CosmosItemResponse <SalesOrder> response = await container.Items.ReadItemAsync <SalesOrder>(
partitionKey : "Account1",
id : "SalesOrder1");
// You can measure the throughput consumed by any operation by inspecting the RequestCharge property
Console.WriteLine("Item read by Id {0}", response.Resource);
Console.WriteLine("Request Units Charge for reading a Item by Id {0}", response.RequestCharge);
SalesOrder readOrder = (SalesOrder)response;
}
public async Task CreateDropItemUndefinedPartitionKeyTest()
{
dynamic testItem = new
{
id = Guid.NewGuid().ToString()
};
CosmosItemResponse <dynamic> response = await this.Container.Items.CreateItemAsync <dynamic>(partitionKey : Undefined.Value, item : testItem);
Assert.IsNotNull(response);
Assert.IsNotNull(response.MaxResourceQuota);
Assert.IsNotNull(response.CurrentResourceQuotaUsage);
CosmosItemResponse <dynamic> deleteResponse = await this.Container.Items.DeleteItemAsync <dynamic>(partitionKey : "[{}]", id : testItem.id);
Assert.IsNotNull(deleteResponse);
}
private static async Task <SalesOrder> CreateItemsAsync()
{
Console.WriteLine("\n1.1 - Creating items");
// Create a SalesOrder object. This object has nested properties and various types including numbers, DateTimes and strings.
// This can be saved as JSON as is without converting into rows/columns.
SalesOrder salesOrder = GetSalesOrderSample("SalesOrder1");
CosmosItemResponse <SalesOrder> response = await container.Items.CreateItemAsync(salesOrder.AccountNumber, salesOrder);
SalesOrder salesOrder1 = response;
Console.WriteLine($"\n1.1.1 - Item created {salesOrder1.Id}");
// As your app evolves, let's say your object has a new schema. You can insert SalesOrderV2 objects without any
// changes to the database tier.
SalesOrder2 newSalesOrder = GetSalesOrderV2Sample("SalesOrder2");
CosmosItemResponse <SalesOrder2> response2 = await container.Items.CreateItemAsync(newSalesOrder.AccountNumber, newSalesOrder);
SalesOrder2 salesOrder2 = response2;
Console.WriteLine($"\n1.1.2 - Item created {salesOrder2.Id}");
// For better performance create a SalesOrder object from a stream.
SalesOrder salesOrderV3 = GetSalesOrderSample("SalesOrderV3");
using (Stream stream = Program.ToStream <SalesOrder>(salesOrderV3))
{
using (CosmosResponseMessage responseMessage = await container.Items.CreateItemStreamAsync(salesOrderV3.AccountNumber, stream))
{
// Item stream operations do not throw exceptions for better performance
if (responseMessage.IsSuccessStatusCode)
{
SalesOrder streamResponse = FromStream <SalesOrder>(responseMessage.Content);
Console.WriteLine($"\n1.1.2 - Item created {streamResponse.Id}");
}
else
{
Console.WriteLine($"Create item from stream failed. Status code: {responseMessage.StatusCode} Message: {responseMessage.ErrorMessage}");
}
}
}
return(salesOrder);
}
public async Task TestPreProcessingHandler()
{
CosmosRequestHandler preProcessHandler = new PreProcessingTestHandler();
CosmosClient client = MockDocumentClient.CreateMockCosmosClient((builder) => builder.AddCustomHandlers(preProcessHandler));
Assert.IsTrue(typeof(RequestInvokerHandler).Equals(client.RequestHandler.GetType()));
Assert.IsTrue(typeof(PreProcessingTestHandler).Equals(client.RequestHandler.InnerHandler.GetType()));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
HttpStatusCode[] testHttpStatusCodes = new HttpStatusCode[]
{
HttpStatusCode.OK,
HttpStatusCode.NotFound
};
// User operations
foreach (HttpStatusCode code in testHttpStatusCodes)
{
CosmosItemRequestOptions options = new CosmosItemRequestOptions();
options.Properties = new Dictionary <string, object>();
options.Properties.Add(PreProcessingTestHandler.StatusCodeName, code);
CosmosItemResponse <object> response = await container.Items.ReadItemAsync <object>("pk1", "id1", options);
Console.WriteLine($"Got status code {response.StatusCode}");
Assert.AreEqual(code, response.StatusCode);
}
// Meta-data operations
foreach (HttpStatusCode code in testHttpStatusCodes)
{
CosmosContainerRequestOptions options = new CosmosContainerRequestOptions();
options.Properties = new Dictionary <string, object>();
options.Properties.Add(PreProcessingTestHandler.StatusCodeName, code);
CosmosContainerResponse response = await container.DeleteAsync(options);
Console.WriteLine($"Got status code {response.StatusCode}");
Assert.AreEqual(code, response.StatusCode);
}
}
public async Task ItemRequestOptionAccessConditionTest()
{
// Create an item
ToDoActivity testItem = (await this.CreateRandomItems(1, randomPartitionKey: true)).First();
// Create an access condition that will fail because the etag will be different
AccessCondition accessCondition = new AccessCondition
{
// Random etag
Condition = Guid.NewGuid().ToString(),
Type = AccessConditionType.IfMatch
};
CosmosItemRequestOptions itemRequestOptions = new CosmosItemRequestOptions()
{
AccessCondition = accessCondition
};
try
{
CosmosItemResponse <ToDoActivity> response = await this.Container.Items.ReplaceItemAsync <ToDoActivity>(
partitionKey : testItem.status,
id : testItem.id,
item : testItem,
requestOptions : itemRequestOptions);
Assert.Fail("Access condition should have failed");
}
catch (CosmosException e)
{
Assert.IsNotNull(e);
Assert.AreEqual(HttpStatusCode.PreconditionFailed, e.StatusCode, e.Message);
Assert.IsNotNull(e.ActivityId);
Assert.IsTrue(e.RequestCharge > 0);
}
finally
{
CosmosItemResponse <ToDoActivity> deleteResponse = await this.Container.Items.DeleteItemAsync <ToDoActivity>(partitionKey : testItem.status, id : testItem.id);
Assert.IsNotNull(deleteResponse);
}
}
private static async Task ReplaceItemAsync(SalesOrder order)
{
//******************************************************************************************************************
// 1.5 - Replace a item
//
// Just update a property on an existing item and issue a Replace command
//******************************************************************************************************************
Console.WriteLine("\n1.5 - Replacing a item using its Id");
order.ShippedDate = DateTime.UtcNow;
CosmosItemResponse <SalesOrder> response = await container.Items.ReplaceItemAsync(
partitionKey : order.AccountNumber,
id : order.Id,
item : order);
SalesOrder updated = response.Resource;
Console.WriteLine($"Request charge of replace operation: {response.RequestCharge}");
Console.WriteLine($"Shipped date of updated item: {updated.ShippedDate}");
}
private static async Task ReplaceItemAsync(SalesOrder order)
{
//******************************************************************************************************************
// 1.5 - Replace a item
//
// Just update a property on an existing item and issue a Replace command
//******************************************************************************************************************
Console.WriteLine("\n1.5 - Replacing a item using its Id");
order.ShippedDate = DateTime.UtcNow;
CosmosItemResponse <SalesOrder> response = await container.Items.ReplaceItemAsync(
partitionKey : order.AccountNumber,
id : order.Id,
item : order);
SalesOrder updated = response.Resource;
Console.WriteLine($"Request charge of replace operation: {response.RequestCharge}");
Console.WriteLine($"Shipped date of updated item: {updated.ShippedDate}");
order.ShippedDate = DateTime.UtcNow;
using (Stream stream = Program.ToStream <SalesOrder>(order))
{
using (CosmosResponseMessage responseMessage = await container.Items.ReplaceItemStreamAsync(
partitionKey: order.AccountNumber,
id: order.Id,
streamPayload: stream))
{
// Item stream operations do not throw exceptions for better performance
if (responseMessage.IsSuccessStatusCode)
{
SalesOrder streamResponse = FromStream <SalesOrder>(responseMessage.Content);
Console.WriteLine($"\n1.5.2 - Item replace via stream {streamResponse.Id}");
}
else
{
Console.WriteLine($"Replace item from stream failed. Status code: {responseMessage.StatusCode} Message: {responseMessage.ErrorMessage}");
}
}
}
}
public async Task CreateDropMultiPolygonTest()
{
SpatialItem spatialItem = new SpatialItem
{
Name = spatialName,
partitionKey = Guid.NewGuid().ToString(),
id = Guid.NewGuid().ToString(),
multiPolygon = GetMultiPoygon(),
};
CosmosItemResponse <SpatialItem> createResponse = await this.Container.Items.CreateItemAsync <SpatialItem>(partitionKey : spatialItem.partitionKey, item : spatialItem);
Assert.IsNotNull(createResponse);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
CosmosItemResponse <SpatialItem> readResponse = await this.Container.Items.ReadItemAsync <SpatialItem>(partitionKey : spatialItem.partitionKey, id : spatialItem.id);
Assert.IsNotNull(readResponse);
Assert.AreEqual(HttpStatusCode.OK, readResponse.StatusCode);
Assert.IsNotNull(readResponse.Resource.multiPolygon);
IOrderedQueryable <SpatialItem> multipolygonQuery =
this.documentClient.CreateDocumentQuery <SpatialItem>(this.Container.Link, new FeedOptions()
{
EnableScanInQuery = true, EnableCrossPartitionQuery = true
});
SpatialItem[] withinQuery = multipolygonQuery
.Where(f => f.multiPolygon.Within(GetMultiPoygon()) && f.multiPolygon.IsValid())
.ToArray();
Assert.IsTrue(withinQuery.Length == 1);
foreach (var item in withinQuery)
{
Assert.IsTrue(item.multiPolygon.Equals(GetMultiPoygon()));
}
CosmosItemResponse <SpatialItem> deleteResponse = await this.Container.Items.DeleteItemAsync <SpatialItem>(partitionKey : spatialItem.partitionKey, id : spatialItem.id);
Assert.IsNotNull(deleteResponse);
Assert.AreEqual(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
public async Task ValidateTriggersTest()
{
// Prevent failures if previous test did not clean up correctly
await this.container.Triggers["addTax"].DeleteAsync();
ToDoActivity item = new ToDoActivity()
{
id = Guid.NewGuid().ToString(),
cost = 9001,
description = "trigger_test_item",
status = "Done",
taskNum = 1
};
CosmosTrigger cosmosTrigger = await this.container.Triggers.CreateTriggerAsync(
new CosmosTriggerSettings
{
Id = "addTax",
Body = TriggersTests.GetTriggerFunction(".20"),
TriggerOperation = TriggerOperation.All,
TriggerType = Cosmos.TriggerType.Pre
});
CosmosItemRequestOptions options = new CosmosItemRequestOptions()
{
PreTriggers = new List <string>()
{
cosmosTrigger.Id
},
};
CosmosItemResponse <dynamic> createdItem = await this.container.Items.CreateItemAsync <dynamic>(item.status, item, options);
double itemTax = createdItem.Resource.tax;
Assert.AreEqual(item.cost * .20, itemTax);
// Delete existing user defined functions.
await cosmosTrigger.DeleteAsync();
}
