/// <summary> /// Updates the specified subscription's configuration. /// <br/> /// Transactions Per Minute (TPM) per-tenancy limit for this operation: 60. /// /// </summary> /// <param name="request">The request object containing the details to send. Required.</param> /// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param> /// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param> /// <returns>A response object containing details about the completed operation</returns> /// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/ons/UpdateSubscription.cs.html">here</a> to see an example of how to use UpdateSubscription API.</example> public async Task <UpdateSubscriptionResponse> UpdateSubscription(UpdateSubscriptionRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default) { logger.Trace("Called updateSubscription"); Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/subscriptions/{subscriptionId}".Trim('/'))); HttpMethod method = new HttpMethod("PUT"); HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request); requestMessage.Headers.Add("Accept", "application/json"); GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration); HttpResponseMessage responseMessage; try { if (retryingClient != null) { responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false); } else { responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false); } this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage); return(Converter.FromHttpResponseMessage <UpdateSubscriptionResponse>(responseMessage)); } catch (Exception e) { logger.Error($"UpdateSubscription failed with error: {e.Message}"); throw; } }
private static void updateSubscription(IoTDAClient client) { UpdateSubscriptionRequest req = new UpdateSubscriptionRequest { SubscriptionId = "4c961c93-376c-4083-9c27-2e88b43b3c0d", Body = new UpdateSubReq() { Callbackurl = "https://0.0.0.0:443/deviceActivate" } }; try { var resp = client.UpdateSubscription(req); Console.WriteLine(resp.HttpStatusCode); Console.WriteLine(resp); } catch (RequestTimeoutException requestTimeoutException) { Console.WriteLine(requestTimeoutException.ErrorMessage); } catch (ServiceResponseException clientRequestException) { Console.WriteLine(clientRequestException.HttpStatusCode); Console.WriteLine(clientRequestException.ErrorCode); Console.WriteLine(clientRequestException.ErrorMsg); } catch (ConnectionException connectionException) { Console.WriteLine(connectionException.ErrorMessage); } }
public async Task UpdatesSubscriptionPreservingMetadata() { // given var subscription = await _resourceFactory.CreateSubscriptionFor(_mandate); var request = new UpdateSubscriptionRequest { Id = subscription.Id, Amount = 456, Name = "Updated subscription name", PaymentReference = "PR456789" }; var subject = new SubscriptionsClient(_clientConfiguration); // when var result = await subject.UpdateAsync(request); // then Assert.That(result.Item.Id, Is.EqualTo(request.Id)); Assert.That(result.Item.Amount, Is.EqualTo(request.Amount)); Assert.That(result.Item.Metadata, Is.EqualTo(subscription.Metadata)); Assert.That(result.Item.Name, Is.EqualTo(request.Name)); Assert.That(result.Item.PaymentReference, Is.EqualTo(request.PaymentReference)); }
public Subscription UpdateDeadLetterPolicy(string projectId, string topicId, string subscriptionId, string deadLetterTopicId) { SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create(); // This is an existing topic that the subscription with dead letter policy is attached to. TopicName topicName = TopicName.FromProjectTopic(projectId, topicId); // This is an existing subscription with a dead letter policy. SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId); // This is an existing dead letter topic that the subscription with dead letter policy forwards // dead letter messages to. var deadLetterTopic = TopicName.FromProjectTopic(projectId, deadLetterTopicId).ToString(); // Construct the subscription with the dead letter policy you expect to have after the update. // Here, values in the required fields (name, topic) help identify the subscription. var subscription = new Subscription { SubscriptionName = subscriptionName, TopicAsTopicName = topicName, DeadLetterPolicy = new DeadLetterPolicy { DeadLetterTopic = deadLetterTopic, MaxDeliveryAttempts = 20, } }; var request = new UpdateSubscriptionRequest { Subscription = subscription, // Construct a field mask to indicate which field to update in the subscription. UpdateMask = new FieldMask { Paths = { "dead_letter_policy" } } }; var updatedSubscription = subscriber.UpdateSubscription(request); return updatedSubscription; }
public Subscription RemoveDeadLetterPolicy(string projectId, string topicId, string subscriptionId) { SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create(); // This is an existing topic that the subscription with dead letter policy is attached to. TopicName topicName = TopicName.FromProjectTopic(projectId, topicId); // This is an existing subscription with dead letter policy. SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId); var subscription = new Subscription() { SubscriptionName = subscriptionName, TopicAsTopicName = topicName, DeadLetterPolicy = null }; var request = new UpdateSubscriptionRequest { Subscription = subscription, UpdateMask = new FieldMask { Paths = { "dead_letter_policy" } } }; var updatedSubscription = subscriber.UpdateSubscription(request); return(updatedSubscription); }
internal virtual UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request) { var marshaller = UpdateSubscriptionRequestMarshaller.Instance; var unmarshaller = UpdateSubscriptionResponseUnmarshaller.Instance; return(Invoke <UpdateSubscriptionRequest, UpdateSubscriptionResponse>(request, marshaller, unmarshaller)); }
protected override void ProcessRecord() { base.ProcessRecord(); UpdateSubscriptionRequest request; try { request = new UpdateSubscriptionRequest { SubscriptionId = SubscriptionId, OspHomeRegion = OspHomeRegion, CompartmentId = CompartmentId, UpdateSubscriptionDetails = UpdateSubscriptionDetails, OpcRequestId = OpcRequestId, IfMatch = IfMatch }; response = client.UpdateSubscription(request).GetAwaiter().GetResult(); WriteOutput(response, response.Subscription); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
public async Task <IActionResult> UpdateSubscription(long restaurant, [FromForm] UpdateSubscriptionRequest request) { var command = new UpdateSubscriptionCommand(restaurant, request.Subscription); return(await HandleActionResultFor(command)); }
public async Task UpdatesSubscriptionReplacingMetadata() { // given var subscription = await _resourceFactory.CreateSubscriptionFor(_mandate); var request = new UpdateSubscriptionRequest { Id = subscription.Id, Amount = 456, Metadata = new Dictionary <string, string> { ["Key4"] = "Value4", ["Key5"] = "Value5", ["Key6"] = "Value6", }, Name = "Updated subscription name", PaymentReference = "PR456789" }; var subject = new SubscriptionsClient(_clientConfiguration); // when var result = await subject.UpdateAsync(request); // then Assert.That(result.Item.Id, Is.EqualTo(request.Id)); Assert.That(result.Item.Amount, Is.EqualTo(request.Amount)); Assert.That(result.Item.Metadata, Is.EqualTo(request.Metadata)); Assert.That(result.Item.Name, Is.EqualTo(request.Name)); Assert.That(result.Item.PaymentReference, Is.EqualTo(request.PaymentReference)); }
public async Task <IActionResult> Update([FromRoute] int id, UpdateSubscriptionRequest request) { var subscription = await _subscriptionService.UpdateSubscriptionAsync(id, request); var mapped = _mapper.Map <SubscriptionResponse>(subscription); return(Ok(new ApiOkResponse(mapped))); }
/// <summary> /// Initiates the asynchronous execution of the UpdateSubscription operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UpdateSubscription operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/shield-2016-06-02/UpdateSubscription">REST API Reference for UpdateSubscription Operation</seealso> public virtual Task <UpdateSubscriptionResponse> UpdateSubscriptionAsync(UpdateSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = UpdateSubscriptionRequestMarshaller.Instance; var unmarshaller = UpdateSubscriptionResponseUnmarshaller.Instance; return(InvokeAsync <UpdateSubscriptionRequest, UpdateSubscriptionResponse>(request, marshaller, unmarshaller, cancellationToken)); }
public async Task <Subscription> UpdateSubscriptionAsync(long id, UpdateSubscriptionRequest updateSubscriptionRequest) { ValidateModel(updateSubscriptionRequest); var response = await PutAsJsonAsync($"/subscriptions/{id}", JsonConvert.SerializeObject(updateSubscriptionRequest)).ConfigureAwait(false); return(JsonConvert.DeserializeObject <SubscriptionResponse>( await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Subscription); }
internal virtual UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSubscriptionResponseUnmarshaller.Instance; return(Invoke <UpdateSubscriptionResponse>(request, options)); }
/// <summary> /// 修改订阅 /// </summary> public async Task <UpdateSubscriptionResponse> UpdateSubscriptionAsync(UpdateSubscriptionRequest updateSubscriptionRequest) { Dictionary <string, string> urlParam = new Dictionary <string, string>(); urlParam.Add("subscription_id", updateSubscriptionRequest.SubscriptionId.ToString()); string urlPath = HttpUtils.AddUrlPath("/v5/iot/{project_id}/subscriptions/{subscription_id}", urlParam); SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", updateSubscriptionRequest); HttpResponseMessage response = await DoHttpRequestAsync("PUT", request); return(JsonUtils.DeSerialize <UpdateSubscriptionResponse>(response)); }
public void UpdateSubscriptionRequestIsNullThrows() { // given var subject = new SubscriptionsClient(_clientConfiguration); UpdateSubscriptionRequest request = null; // when AsyncTestDelegate test = () => subject.UpdateAsync(request); // then var ex = Assert.ThrowsAsync <ArgumentNullException>(test); Assert.That(ex.ParamName, Is.EqualTo(nameof(request))); }
public async Task <Subscription> UpdateSubscriptionAsync(int id, UpdateSubscriptionRequest request) { var subscription = await GetSubscriptionAsync(id); subscription.Name = request.Name; subscription.ValueCoins = request.ValueCoins; subscription.IsActive = request.IsActive; subscription.ModifiedAt = DateTime.UtcNow; await _uow.SubscriptionRepository.UpdateAsync(subscription, id); await _uow.CommitAsync(); return(subscription); }
public async Task CallsUpdateSubscriptionEndpoint() { // given var subject = new SubscriptionsClient(_clientConfiguration); var request = new UpdateSubscriptionRequest { Id = "SB12345678" }; // when await subject.UpdateAsync(request); // then _httpTest .ShouldHaveCalled("https://api.gocardless.com/subscriptions") .WithVerb(HttpMethod.Put); }
public void UpdateSubscriptionRequestIdIsNullOrWhiteSpaceThrows(string id) { // given var subject = new SubscriptionsClient(_clientConfiguration); var request = new UpdateSubscriptionRequest { Id = id }; // when AsyncTestDelegate test = () => subject.UpdateAsync(request); // then var ex = Assert.ThrowsAsync <ArgumentException>(test); Assert.That(ex.ParamName, Is.EqualTo(nameof(request.Id))); }
public ActionResult<Subscription> UpdateSubscription([FromBody] UpdateSubscriptionRequest req) { var service = new SubscriptionService(); var subscription = service.Get(req.Subscription); var options = new SubscriptionUpdateOptions { CancelAtPeriodEnd = false, Items = new List<SubscriptionItemOptions> { new SubscriptionItemOptions { Id = subscription.Items.Data[0].Id, Price = Environment.GetEnvironmentVariable(req.NewPrice), } } }; var updatedSubscription = service.Update(req.Subscription, options); return updatedSubscription; }
public async Task ThenItShouldCallManagerWithSubscriptionDetails(string subscriptionId) { var request = new UpdateSubscriptionRequest { SubscriptionId = subscriptionId, Publisher = _fixture.Create <string>(), EventType = _fixture.Create <string>(), EndpointUrl = _fixture.Create <Uri>().ToString(), }; var httpRequest = TestHelpers.BuildRequestWithBody(request); await _function.RunAsync(httpRequest, _cancellationToken); _subscriptionManagerMock.Verify(m => m.UpdateSubscriptionAsync( It.Is <Subscription>(s => s.Id == subscriptionId && s.Publisher == request.Publisher && s.EventType == request.EventType && s.EndpointUrl == request.EndpointUrl), _cancellationToken), Times.Once); }
public async Task UpdatesSubscriptionForMerchant() { // given var accessToken = Environment.GetEnvironmentVariable("GoCardlessMerchantAccessToken"); var configuration = ClientConfiguration.ForSandbox(accessToken); var resourceFactory = new ResourceFactory(configuration); var mandatesClient = new MandatesClient(configuration); var mandate = (await mandatesClient.GetPageAsync()).Items.First(); var subscription = await resourceFactory.CreateSubscriptionFor(mandate, paymentReference : null); var request = new UpdateSubscriptionRequest { Id = subscription.Id, Amount = 456, AppFee = 34, Metadata = new Dictionary <string, string> { ["Key4"] = "Value4", ["Key5"] = "Value5", ["Key6"] = "Value6", }, Name = "Updated subscription name" }; var subject = new SubscriptionsClient(configuration); // when var result = await subject.UpdateAsync(request); // then Assert.That(result.Item.Id, Is.EqualTo(request.Id)); Assert.That(result.Item.Amount, Is.EqualTo(request.Amount)); Assert.That(result.Item.AppFee, Is.EqualTo(request.AppFee)); Assert.That(result.Item.Metadata, Is.EqualTo(request.Metadata)); Assert.That(result.Item.Name, Is.EqualTo(request.Name)); }
/// <summary> /// Updates the specified subscription's configuration. /// Transactions Per Minute (TPM) per-tenancy limit for this operation: 60. /// </summary> /// <param name="request"></param> /// <returns></returns> public async Task <UpdateSubscriptionResponse> UpdateSubscription(UpdateSubscriptionRequest request) { var uri = new Uri($"{GetEndPoint(NotificationServices.Subscriptions, this.Region)}/{request.SubscriptionId}"); var httpRequestHeaderParam = new HttpRequestHeaderParam() { OpcRequestId = request.OpcRequestId, IfMatch = request.IfMatch }; var webResponse = await this.RestClientAsync.Put(uri, request.UpdateSubscriptionDetails, httpRequestHeaderParam); using (var stream = webResponse.GetResponseStream()) using (var reader = new StreamReader(stream)) { var response = reader.ReadToEnd(); return(new UpdateSubscriptionResponse() { OpcRequestId = webResponse.Headers.Get("opc-request-id"), ETag = webResponse.Headers.Get("etag"), UpdateSubscriptionDetails = this.JsonSerializer.Deserialize <UpdateSubscriptionDetails>(response) }); } }
public IHttpActionResult UpdateSubscription(UpdateSubscriptionRequest updateSubscriptionRequest) { var responses = new Responses(); try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (Utility.UserId < 0) { return(BadRequest(Utility.INVALID_USER)); } var Subscription = new Subscription() { SubscriptionId = updateSubscriptionRequest.SubscriptionId, StartDate = updateSubscriptionRequest.StartDate, PaymentDate = updateSubscriptionRequest.PaymentDate, IsExpired = updateSubscriptionRequest.IsExpired, IsActive = updateSubscriptionRequest.IsActive, ModifiedBy = Utility.UserId }; int result = iSubscription.UpdateSubscription(Subscription); switch (result) { case -2: responses.Status = Utility.ERROR_STATUS_RESPONSE; responses.Description = "Subscription already exists."; break; case -3: responses.Status = Utility.ERROR_STATUS_RESPONSE; responses.Description = "Subscription doesn't exist."; break; default: if (result > 0) { string userName = string.Empty; var userProfile = new UserProfile() { UserId = updateSubscriptionRequest.UserId }; var userProfiles = iUserProfile.GetUserProfile(userProfile); if (userProfiles != null) { userName = userProfiles.First().UserName; var SubscriptionEmailHtmlCode = System.IO.File.ReadAllText(string.Format("{0}", HttpContext.Current.Server.MapPath(string.Format("{0}{1}", ConfigurationManager.AppSettings["EmailTemplatePath"], (updateSubscriptionRequest.StartDate != null ? ConfigurationManager.AppSettings["SubscriptionUpdateEmailTemplateForUser"] : ConfigurationManager.AppSettings["UnsubscriptionEmailTemplateForUser"]))))); var mainTemplateHtmlCode = System.IO.File.ReadAllText(string.Format("{0}", HttpContext.Current.Server.MapPath(string.Format("{0}{1}", ConfigurationManager.AppSettings["EmailTemplatePath"], ConfigurationManager.AppSettings["MainEmailTemplate"])))); mainTemplateHtmlCode = mainTemplateHtmlCode.Replace("[SITEURL]", ConfigurationManager.AppSettings["SiteUrl"]); mainTemplateHtmlCode = mainTemplateHtmlCode.Replace("[SITENAME]", ConfigurationManager.AppSettings["SiteName"]); mainTemplateHtmlCode = mainTemplateHtmlCode.Replace("[PAGECONTENT]", SubscriptionEmailHtmlCode); string subject = "Subscription | Demystify Fema"; string body = mainTemplateHtmlCode; string displayName = ConfigurationManager.AppSettings["SiteName"]; string emailTo = userName; bool isMailSentToUser = Utility.SendMail(emailTo, string.Empty, string.Empty, subject, body, displayName, string.Empty, true); try { var subscriptionHistory = new SubscriptionHistory() { SubscriptionHistoryId = result, IsMailSentToUser = isMailSentToUser, ModifiedBy = Utility.UserId }; iSubscription.UpdateSubscriptionHistoryMailSent(subscriptionHistory); } catch (Exception ex) { Utility.WriteLog("AddSubscription", updateSubscriptionRequest, "Error while updating Subscription History mail sent. (SubscriptionUserController)", ex.ToString()); } } responses.Status = Utility.SUCCESS_STATUS_RESPONSE; responses.Description = "Subscription updated successfully."; } else { responses.Status = Utility.ERROR_STATUS_RESPONSE; responses.Description = "Error while updating Subscription."; } break; } } catch (Exception ex) { responses.Status = Utility.ERROR_STATUS_RESPONSE; responses.Description = "Error while updating Subscription."; Utility.WriteLog("UpdateSubscription", updateSubscriptionRequest, "Error while updating Subscription. (SubscriptionAdminController)", ex.ToString()); } return(Ok(responses)); }
/// <summary> /// Update a subscription /// </summary> public static void UpdateSubscription(UpdateSubscriptionRequest request, Action <UpdateSubscriptionResult> resultCallback, Action <PlayFabError> errorCallback, object customData = null, Dictionary <string, string> extraHeaders = null) { PlayFabHttp.MakeApiCall("/Catalog/UpdateSubscription", request, AuthType.EntityToken, resultCallback, errorCallback, customData, extraHeaders); }
public ActionResult <UpdateSubscriptionResponse> UpdateSubscription([FromBody] UpdateSubscriptionRequest req) { if (!ModelState.IsValid) { return(this.FailWithMessage("invalid params")); } var newPrice = Environment.GetEnvironmentVariable(req.NewPrice); if (newPrice is null || newPrice == "") { return(this.FailWithMessage($"No price with the new price ID ({req.NewPrice}) found in .env")); } var service = new SubscriptionService(); Subscription subscription; try { subscription = service.Get(req.Subscription); } catch (StripeException e) { return(this.FailWithMessage($"Failed to retrieve subscription: {e}")); } var currentPrice = subscription.Items.Data[0].Price.Id; List <SubscriptionItemOptions> items; if (currentPrice == newPrice) { items = new List <SubscriptionItemOptions> { new SubscriptionItemOptions { Id = subscription.Items.Data[0].Id, Quantity = req.Quantity, }, }; } else { items = new List <SubscriptionItemOptions> { new SubscriptionItemOptions { Id = subscription.Items.Data[0].Id, Deleted = true, }, new SubscriptionItemOptions { Price = newPrice, Quantity = req.Quantity, }, }; } var options = new SubscriptionUpdateOptions { CancelAtPeriodEnd = false, Items = items, ProrationBehavior = "always_invoice", }; var updatedSubscription = service.Update(req.Subscription, options); return(new UpdateSubscriptionResponse { Subscription = updatedSubscription, }); }
public async Task <ApiResponse <UpdateSubscriptionResponse> > UpdateSubscriptionAsync(UpdateSubscriptionRequest request) { var updateResponse = new ApiResponse <UpdateSubscriptionResponse>(new UpdateSubscriptionResponse()); _httpClient.DefaultRequestHeaders.Clear(); _httpClient.DefaultRequestHeaders.Add(ConstantString.AuthorizationKey, string.Format(ConstantString.AuthorizationValue, request.AccessToken)); var subsBody = JsonConvert.SerializeObject(request.UpdatingSubscription); var updatingSubsContent = new StringContent(subsBody); updatingSubsContent.Headers.ContentType = new MediaTypeHeaderValue(ConstantString.JsonContentTypeValue); var subsRequest = await _httpClient.PutAsync(ConstantString.SubscriptionSuffix + "/" + request.SubscriptionId, updatingSubsContent).ConfigureAwait(false); var content = await subsRequest.Content.ReadAsStringAsync().ConfigureAwait(false); updateResponse.StatusCode = subsRequest.StatusCode; updateResponse.Headers = subsRequest.Headers.ToDictionary(x => x.Key, x => x.Value.ToString()); updateResponse.Body = JsonConvert.DeserializeObject <UpdateSubscriptionResponse>(content); return(updateResponse); }
public UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request) { return(Execute(() => InternalService.UpdateSubscription(request))); }
public UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request) { return(ExecuteAction <UpdateSubscriptionResponse>(request)); }