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(); }