private Uri GetDocumentLink(string id) { return(UriFactory.CreateDocumentUri(_settings.DatabaseName, _settings.CollectionName, id)); }
public async Task <Document> UpdatePersonAsync(string id, T person) { return(await client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id), person)); }
public async Task <Document> UpdateItemAsync(string id, T item) { return(await client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id), item)); }
private Uri DocUri(string id) { return(UriFactory.CreateDocumentUri(dbName, CollName, id)); }
public static async Task DeleteItemAsync(string id) { await client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id)); //, new RequestOptions(){PartitionKey = new PartitionKey(id)}); }
Uri GetDocumentUri(string id) { return(UriFactory.CreateDocumentUri(_databaseId, _collectionId, id)); }
public async Task DeleteAsync(string id) { await _client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(_databaseId, _collectionId, id)).ConfigureAwait(false); }
private Uri GetDocumentLink <T>(string id) where T : IDataDocument { return(UriFactory.CreateDocumentUri(databaseId, collectionId, id)); }
public async Task Run() { WriteLine("1. Insert, pre trigger"); WriteLine("2. Update, pre trigger"); WriteLine("3. Create triggers"); SPOption option = (SPOption)ProgramHelper.EnterInt(""); switch (option) { case SPOption.InsertPreTrigger: { ZipModel model = new ZipModel() { City = "Sarajevo", Pop = 1854, State = "BiH", Loc = new Point(43.8607994, 18.4018904), Id = "989898" }; Document findZipModel = await _documentRepository.ReadDocumentByIdAsync <Document>(model.Id, UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId)); if (findZipModel != null) { await _documentRepository.DeleteDocument(DatabaseId, CollectionId, findZipModel.Id); } Document document = await _documentRepository.InsertDocument(DatabaseId, CollectionId, model, new RequestOptions { PreTriggerInclude = new[] { "setCreatedDate" } }); Success("New document successfully created."); break; } case SPOption.ReplacePostTrigger: { ZipModel model = await _documentRepository.ReadDocumentByIdAsync <ZipModel>("989898", UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId)); model.City = "Neum"; ZipModel updatedModel = await _documentRepository.UpdateDocument <ZipModel>(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, model.Id), model, new RequestOptions { PreTriggerInclude = new[] { "setUpdatedDate" } }); Success("Document with id >>> " + updatedModel.Id + " <<< updated."); Success("Created date time >>> " + updatedModel.CreatedDateTime.Value.ToString("MM/dd/yyyy hh:mm:ss tt") + " <<<."); Success("Updated date time >>> " + updatedModel.UpdatedDateTime.Value.ToString("MM/dd/yyyy hh:mm:ss tt") + " <<< updated."); break; } case SPOption.CreateTriggers: { Trigger setCreatedDate = new Trigger() { Id = "setCreatedDate", Body = File.ReadAllText(@"Scripts\trSetCreatedDate.js"), TriggerOperation = TriggerOperation.Create, TriggerType = TriggerType.Pre }; Trigger setUpdatedDate = new Trigger() { Id = "setUpdatedDate", Body = File.ReadAllText(@"Scripts\trSetUpdatedDate.js"), TriggerOperation = TriggerOperation.Update, TriggerType = TriggerType.Pre }; Trigger newCreatedTrigger = await _triggerRepository.CreateTriggerAsync(UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId), setCreatedDate); WriteLine(string.Format("Created trigger {0}; RID: {1}", newCreatedTrigger.Id, newCreatedTrigger.ResourceId)); Trigger newUpdatedTrigger = await _triggerRepository.CreateTriggerAsync(UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId), setUpdatedDate); WriteLine(string.Format("Created trigger {0}; RID: {1}", newUpdatedTrigger.Id, newUpdatedTrigger.ResourceId)); break; } } }
/// <summary> /// /// </summary> /// <param name="id"></param> /// <returns></returns> public static async Task <Document> DeleteItemAsync(string id) { return(await client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, typeof(T).Name, id))); }
/// <inheritdoc/> public async Task <Instance> Update(Instance item) { PreProcess(item); ResourceResponse <Document> createDocumentResponse = await Client .ReplaceDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, item.Id), item); Document document = createDocumentResponse.Resource; Instance instance = JsonConvert.DeserializeObject <Instance>(document.ToString()); await PostProcess(instance); return(instance); }
/// <summary> /// /// </summary> /// <param name="id"></param> /// <param name="item"></param> /// <returns></returns> public static async Task <Document> UpdateItemAsync(string id, T item) { return(await client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, typeof(T).Name, id), item)); }
public async Task <Boolean> ReplaceDocumentEntity(string databaseName, string entityName, string document, string idDocument) { var response = await this.client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(databaseName, entityName, idDocument), JsonConvert.DeserializeObject(document)); return(response.StatusCode == HttpStatusCode.OK); }
public async Task <IActionResult> CreateFromBaseKit( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, [CosmosDB(databaseName: "2wr", collectionName: "emergencykits", ConnectionStringSetting = "CosmosDBConnection")] DocumentClient client, [CosmosDB(databaseName: "2wr", collectionName: "basekits", ConnectionStringSetting = "CosmosDBConnection")] DocumentClient baseKitClient, ILogger log) { log.LogInformation($"Creating a new kit off of a base kit"); var authorizationResult = await _apiAuthentication.AuthenticateAsync(req.Headers); if (authorizationResult.Failed) { log.LogWarning(authorizationResult.FailureReason); return(new UnauthorizedResult()); } Uri collectionUri = UriFactory.CreateDocumentCollectionUri("2wr", "emergencykits"); var content = await new StreamReader(req.Body).ReadToEndAsync(); var request = JsonConvert.DeserializeObject <CreateKitFromBaseRequest>(content); var kit = new Kit(); kit.Id = Guid.NewGuid().ToString(); kit.UserId = authorizationResult.User.Identity.Name; //Pull Base kit information by id, Add items from base kit, multiply quantity by the count var baseKitUri = UriFactory.CreateDocumentUri("2wr", "basekits", request.BaseKitId); BaseKit baseKit = null; try { baseKit = (await baseKitClient.ReadDocumentAsync <BaseKit>(baseKitUri, new RequestOptions { PartitionKey = new PartitionKey(request.BaseKitId) })).Document; } catch (DocumentClientException ex) { if (ex.StatusCode == System.Net.HttpStatusCode.NotFound) { log.LogWarning($"Base Kit: {request.BaseKitId} not found."); return(new BadRequestObjectResult("Base Kit not found.")); } } baseKit.Items.ForEach(bki => kit.Items.Add(new KitItem { Id = Guid.NewGuid().ToString(), UserId = authorizationResult.User.Identity.Name, Name = bki.Name, Description = bki.Description, Photo = bki.Photo, Quantity = bki.QuantityPerCount * request.Count, QuantityUnit = bki.QuantityUnit, IsAvailableInKit = false })); Document document = await client.CreateDocumentAsync(collectionUri, kit); return(new OkObjectResult(kit)); }
public async Task <ActionResult <Models.AppUser> > GetUserByDocumentId(string documentId) { try { Models.AppUser user = await _cosmosDBclient.ReadDocumentAsync <Models.AppUser>(UriFactory.CreateDocumentUri( _dbName, _collectionName, documentId)); return(Ok(user)); } catch (DocumentClientException de) { switch (de.StatusCode.Value) { case System.Net.HttpStatusCode.NotFound: return(NotFound()); } } return(BadRequest()); }
static Uri CreateDocumentUri(string id) => UriFactory.CreateDocumentUri(PersonModel.DatabaseId, PersonModel.CollectionId, id);
/// <summary> /// Update instance for a given form id /// </summary> /// <param name="instanceId">the instance id</param> /// <param name="item">the instance</param> /// <returns>The instance</returns> public async Task <Instance> UpdateInstanceInCollectionAsync(Guid instanceId, Instance item) { ResourceResponse <Document> createDocumentResponse = await _client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(databaseId, collectionId, instanceId.ToString()), item); Document document = createDocumentResponse.Resource; Instance instance = JsonConvert.DeserializeObject <Instance>(document.ToString()); return(instance); }
public static Uri CreateDocumentUri(Guid actionPlanId) { return(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, actionPlanId.ToString())); }
public async Task <T> UpdateAsync(string id, T item) { var result = await _client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(_databaseId, _collectionId, id), item).ConfigureAwait(false); return(JsonConvert.DeserializeObject <T>(result.Resource.ToString())); }
public static Uri CreateCustomerDocumentUri(Guid customerId) { return(UriFactory.CreateDocumentUri(CustomerDatabaseId, CustomerCollectionId, customerId.ToString())); }
private Uri GetDocumentUriForEntity(ToDo entity) { var documentUri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, entity.Id.ToString()); return(documentUri); }
public static Uri CreateInteractionDocumentUri(Guid interactionId) { return(UriFactory.CreateDocumentUri(InteractionDatabaseId, InteractionCollectionId, interactionId.ToString()));; }
public void TestStoredProcedure() { // Create a document client with a customer json serializer settings JsonSerializerSettings serializerSettings = new JsonSerializerSettings(); serializerSettings.Converters.Add(new ObjectStringJsonConverter <SerializedObject>(_ => _.Name, _ => SerializedObject.Parse(_))); ConnectionPolicy connectionPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Gateway }; ConsistencyLevel defaultConsistencyLevel = ConsistencyLevel.Session; DocumentClient client = CreateDocumentClient( this.hostUri, this.masterKey, serializerSettings, connectionPolicy, defaultConsistencyLevel); // Create a simple stored procedure var scriptId = "bulkImportScript"; var sproc = new StoredProcedure { Id = scriptId, Body = @" function bulkImport(docs) { var collection = getContext().getCollection(); var collectionLink = collection.getSelfLink(); // The count of imported docs, also used as current doc index. var count = 0; // Validate input. if (!docs) throw new Error(""The array is undefined or null.""); var docsLength = docs.length; if (docsLength == 0) { getContext().getResponse().setBody(0); } // Call the CRUD API to create a document. tryCreate(docs[count], callback); // Note that there are 2 exit conditions: // 1) The createDocument request was not accepted. // In this case the callback will not be called, we just call setBody and we are done. // 2) The callback was called docs.length times. // In this case all documents were created and we don't need to call tryCreate anymore. Just call setBody and we are done. function tryCreate(doc, callback) { // If you are sure that every document will contain its own (unique) id field then // disable the option to auto generate ids. // by leaving this on, the entire document is parsed to check if there is an id field or not // by disabling this, parsing of the document is skipped because you're telling DocumentDB // that you are providing your own ids. // depending on the size of your documents making this change can have a significant // improvement on document creation. var options = { disableAutomaticIdGeneration: true }; var isAccepted = collection.createDocument(collectionLink, doc, options, callback); // If the request was accepted, callback will be called. // Otherwise report current count back to the client, // which will call the script again with remaining set of docs. // This condition will happen when this stored procedure has been running too long // and is about to get cancelled by the server. This will allow the calling client // to resume this batch from the point we got to before isAccepted was set to false if (!isAccepted) getContext().getResponse().setBody(count); } // This is called when collection.createDocument is done and the document has been persisted. function callback(err, doc, options) { if (err) throw err; // One more document has been inserted, increment the count. count++; if (count >= docsLength) { // If we have created all documents, we are done. Just set the response. getContext().getResponse().setBody(count); } else { // Create next document. tryCreate(docs[count], callback); } } } " }; sproc = client.CreateStoredProcedureAsync(collectionUri, sproc).Result.Resource; var doc = new MyObject(1); var args = new dynamic[] { new dynamic[] { doc } }; RequestOptions requestOptions = ApplyRequestOptions(new RequestOptions { PartitionKey = new PartitionKey("value") }, serializerSettings); StoredProcedureResponse <int> scriptResult = client.ExecuteStoredProcedureAsync <int>( sproc.SelfLink, requestOptions, args).Result; var docUri = UriFactory.CreateDocumentUri(databaseName, collectionName, doc.id); var readDoc = client.ReadDocumentAsync <MyObject>(docUri, requestOptions).Result.Document; Assert.IsNotNull(readDoc.SerializedObject); Assert.AreEqual(doc.SerializedObject.Name, readDoc.SerializedObject.Name); }
private Uri CreateDocumentUri(string documentId) { return(UriFactory.CreateDocumentUri(_options.Value.DatabaseName, _options.Value.CollectionName, documentId)); }
public async Task <Document> UpsertItemAsync <T>(string id, T item) where T : class { return(await Client.UpsertDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id), item)); }
public async Task <Document> UpdateItemAsync(T item) { return(await _client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, item.Id.ToString()), item)); }
/// <summary> /// Subscribes to a subscribtion. /// </summary> /// <param name="context">A <see cref="IDialogContext"/>.</param> /// <param name="result">A <see cref="IMessageActivity"/>.</param> /// <returns>A <see cref="Task"/>.</returns> public async Task SubscribeAsync(IDialogContext context, IAwaitable <IMessageActivity> result) { context.ThrowIfNull(nameof(context)); result.ThrowIfNull(nameof(result)); var activity = await result; var text = (activity.RemoveRecipientMention() ?? string.Empty).ToLowerInvariant(); var reply = context.MakeMessage(); var matchSubscribe = Regex.Match(text, CommandMatchSubscribe); var matchUnsubscribe = Regex.Match(text, CommandMatchUnsubscribe); if (matchSubscribe.Success || matchUnsubscribe.Success) { var typing = context.MakeMessage(); typing.Type = ActivityTypes.Typing; await context.PostAsync(typing); } if (matchSubscribe.Success) { var subscriptionType = (SubscriptionType)Enum.Parse(typeof(SubscriptionType), matchSubscribe.Groups[1].Value, true); var querySpec = new SqlQuerySpec { QueryText = "SELECT * FROM subscriptions s WHERE s.channelId = @channelId AND s.userId = @userId AND s.subscriptionType = @subscriptionType", Parameters = new SqlParameterCollection { new SqlParameter("@channelId", activity.ChannelId), new SqlParameter("@userId", activity.From.Id), new SqlParameter("@subscriptionType", subscriptionType) } }; var subscription = this.documentClient .CreateDocumentQuery <Subscription>(UriFactory.CreateDocumentCollectionUri("botdb", "subscriptioncollection"), querySpec) .ToList() .FirstOrDefault(); if (subscription != null) { context.Done(reply); return; } var teamProjects = await this.VstsService.GetProjects(this.Account, this.Profile.Token); var teamProject = teamProjects.FirstOrDefault(tp => tp.Name.Equals(this.TeamProject, StringComparison.OrdinalIgnoreCase)); if (teamProject == null) { context.Done(reply); return; } subscription = new Subscription { BotId = activity.Recipient.Id, BotName = activity.Recipient.Name, ChannelId = activity.ChannelId, IsActive = true, ProfileId = this.Profile.Id, RecipientId = activity.From.Id, RecipientName = activity.From.Name, ServiceUri = new Uri(activity.ServiceUrl), SubscriptionType = subscriptionType, TenantId = activity.ChannelId.Equals(ChannelIds.Msteams) ? activity.GetTenantId() : string.Empty, UserId = activity.From.Id }; var strategy = this.strategies.First(s => s.CanGetSubscription(subscriptionType)); var s2 = strategy.GetSubscription(subscription.Id, teamProject); var r = await this.VstsService.CreateSubscription(this.Account, s2, this.Profile.Token); subscription.IdentityId = r.CreatedBy.Id; subscription.SubscriptionId = r.Id; await this.documentClient.UpsertDocumentAsync( UriFactory.CreateDocumentCollectionUri("botdb", "subscriptioncollection"), subscription); reply.Text = Labels.Subscribed; await context.PostAsync(reply); context.Done(reply); } else if (matchUnsubscribe.Success) { var subscriptionType = (SubscriptionType)Enum.Parse(typeof(SubscriptionType), matchUnsubscribe.Groups[1].Value, true); var querySpec = new SqlQuerySpec { QueryText = "SELECT * FROM subscriptions s WHERE s.channelId = @channelId AND s.userId = @userId AND s.subscriptionType = @subscriptionType", Parameters = new SqlParameterCollection { new SqlParameter("@channelId", activity.ChannelId), new SqlParameter("@userId", activity.From.Id), new SqlParameter("@subscriptionType", subscriptionType) } }; var subscription = this.documentClient .CreateDocumentQuery <Subscription>(UriFactory.CreateDocumentCollectionUri("botdb", "subscriptioncollection"), querySpec) .ToList() .FirstOrDefault(); if (subscription != null) { await this.documentClient.DeleteDocumentAsync(UriFactory.CreateDocumentUri("botdb", "subscriptioncollection", subscription.Id.ToString())); await this.VstsService.DeleteSubscription(this.Account, subscription.SubscriptionId, this.Profile.Token); reply.Text = Labels.Unsubscribed; await context.PostAsync(reply); } context.Done(reply); } else { context.Fail(new UnknownCommandException(activity.Text)); } }
public async Task DeleteItemAsync(Guid id) { await _client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id.ToString())); }
public async Task DeleteItemAsync(string id) { await client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id)); }
public async Task UpdateAsync(Entity document) { var documentUri = UriFactory.CreateDocumentUri(_dataStorageOptions.DatabaseId, _collectionId, document.Id); var response = await _client.ReplaceDocumentAsync(documentUri, document).ConfigureAwait(false); }