public async Task CreateDataSubscriptionAsync() { try { var subscriptionRequest = new CreateSubscriptionRequest { RequestedPublishingInterval = _clientOptions.RequestedPublishingInterval, RequestedMaxKeepAliveCount = _clientOptions.RequestedMaxKeepAliveCount, RequestedLifetimeCount = _clientOptions.RequestedLifetimeCount, PublishingEnabled = _clientOptions.PublishingEnabled }; var subscriptionResponse = await channel.CreateSubscriptionAsync(subscriptionRequest); var id = subscriptionResponse.SubscriptionId; subscriptions.Add(id); _logger.LogInformation($"Created subscription '{id}' at {DateTime.Now}."); } catch (Exception ex) { await channel.AbortAsync(); _logger.LogError(ex.Message); } }
public string GravaAssinaturaApi(CreateSubscriptionRequest assinaturaApi) { // Secret key fornecida pela Mundipagg var basicAuthUserName = SistemaSingleton.Instancia.TokenApi; // Senha em branco. Passando apenas a secret key var basicAuthPassword = ""; var client = new MundiAPIClient(basicAuthUserName, basicAuthPassword); var response = client.Subscriptions.CreateSubscription(assinaturaApi); assinaturaDal.AssinaturaGravadaNaApiAtualizaBanco(assinaturaApi.Metadata["id"], response.Id); assinaturaDal.GravaIdApiListaItens(response.Items, assinaturaApi.Metadata["id"]); var clienteDal = new ClienteDal(); var codCliente = clienteDal.GetClienteByAssinatura(assinaturaApi.Metadata["id"]); clienteDal.ClienteGravado(codCliente, response.Customer.Id); var cartaoDal = new CartaoDal(); var codCard = cartaoDal.getCardByIdAssinatura(assinaturaApi.Metadata["id"]); cartaoDal.CartaoGravadoNaApiAtualizaBanco(codCard, response.Card.Id); return(response.Id); }
/// <summary> /// Activates AWS Shield Advanced for an account. /// </summary> /// <param name="request">Container for the necessary parameters to execute the CreateSubscription service method.</param> /// /// <returns>The response from the CreateSubscription service method, as returned by Shield.</returns> /// <exception cref="Amazon.Shield.Model.InternalErrorException"> /// Exception that indicates that a problem occurred with the service infrastructure. /// You can retry the request. /// </exception> /// <exception cref="Amazon.Shield.Model.ResourceAlreadyExistsException"> /// Exception indicating the specified resource already exists. /// </exception> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/shield-2016-06-02/CreateSubscription">REST API Reference for CreateSubscription Operation</seealso> public CreateSubscriptionResponse CreateSubscription(CreateSubscriptionRequest request) { var marshaller = new CreateSubscriptionRequestMarshaller(); var unmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return(Invoke <CreateSubscriptionRequest, CreateSubscriptionResponse>(request, marshaller, unmarshaller)); }
internal virtual CreateSubscriptionResponse CreateSubscription(CreateSubscriptionRequest request) { var marshaller = CreateSubscriptionRequestMarshaller.Instance; var unmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return(Invoke <CreateSubscriptionRequest, CreateSubscriptionResponse>(request, marshaller, unmarshaller)); }
internal async Task <Subscription> CreateSubscriptionFor(Mandate mandate, string paymentReference = "PR123456") { var request = new CreateSubscriptionRequest { Amount = 123, Currency = "GBP", Count = 5, Interval = 3, IntervalUnit = IntervalUnit.Weekly, Links = new SubscriptionLinks { Mandate = mandate.Id }, Metadata = new Dictionary <string, string> { ["Key1"] = "Value1", ["Key2"] = "Value2", ["Key3"] = "Value3", }, Name = "Test subscription", PaymentReference = paymentReference, StartDate = DateTime.Now.AddMonths(1) }; var subscriptionsClient = new SubscriptionsClient(_clientConfiguration); return((await subscriptionsClient.CreateAsync(request)).Item); }
public static CreateZohoSubscriptionRequest CreateCustomerSubscription(CreateSubscriptionRequest request, WpUsers user, string customerID, bool isGift, List <Addon> associatedAddons) { CreateZohoSubscriptionRequest subscriptionRequest = new CreateZohoSubscriptionRequest(); subscriptionRequest.CustomerID = customerID; subscriptionRequest.CustomFields = new List <CustomField>() { new CustomField() { Label = "IsGift", Value = isGift?"true":"false" }, new CustomField() { Label = "CreatedBy", Value = request.UserID } }; if (!isGift) { subscriptionRequest.Customer = new Customer().CreateCustomerObject(request, user); } else { subscriptionRequest.Customer = new Customer().CreateCustomerForGiftObject(request, user); } subscriptionRequest.Plan = new Plan().CreatePlanObject(request); subscriptionRequest.Addons = new List <Addon>().CreateAddOns(associatedAddons); return(subscriptionRequest); }
public async Task <Subscription> CreateSubscriptionAsync(CreateSubscriptionRequest request) { var product = (SubscriptionEnum)request.Product; var subscription = await _uow.SubscriptionRepository.FindAsync(c => c.Product == product); if (subscription != null) { throw new AlreadyExistsException("Subscription already exists"); } subscription = new Subscription { Name = request.Name, Product = product, IsActive = request.IsActive, ValueCoins = request.ValueCoins, CreatedAt = DateTime.UtcNow, ModifiedAt = DateTime.UtcNow }; await _uow.SubscriptionRepository.AddAsync(subscription); await _uow.CommitAsync(); return(subscription); }
public static Customer CreateCustomerForGiftObject(this Customer customer, CreateSubscriptionRequest request, WpUsers user) { customer.BillingAddress = new BillingAddress() { Attention = $"{request.FirstName} {request.LastName}", Country = "NG", State = request.GiftBillingState, City = request.GiftBillingCity, Street = request.GiftBillingStreet, Fax = request.Phone }; customer.CompanyName = request.GiftCustomerName; //CountryCode = "NG", customer.DisplayName = $"{request.GiftFirstName} {request.GiftLastName}"; //user.DisplayName; customer.Email = request.GiftEmail; customer.FirstName = request.GiftFirstName; customer.LastName = request.GiftLastName; customer.CustomerSubType = "Individual"; customer.Mobile = request.ShippingPhoneNo; customer.Phone = request.Phone; customer.ShippingAddress = new ShippingAddress() { Attention = $"{request.GiftFirstName} {request.GiftLastName}", Country = "NG", State = request.GiftShippingState, City = request.GiftShippingCity, Street = request.GiftShippingStreet, Fax = request.ShippingPhoneNo }; return(customer); }
/// <summary> /// Creates a subscription for the specified topic and sends a subscription confirmation URL to the endpoint. The subscription remains in \"Pending\" status until it has been confirmed. /// For information about confirming subscriptions, see /// [To confirm a subscription](https://docs.cloud.oracle.com/iaas/Content/Notification/Tasks/managingtopicsandsubscriptions.htm#confirmSub). /// <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/CreateSubscription.cs.html">here</a> to see an example of how to use CreateSubscription API.</example> public async Task <CreateSubscriptionResponse> CreateSubscription(CreateSubscriptionRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default) { logger.Trace("Called createSubscription"); Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/subscriptions".Trim('/'))); HttpMethod method = new HttpMethod("POST"); 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 <CreateSubscriptionResponse>(responseMessage)); } catch (Exception e) { logger.Error($"CreateSubscription failed with error: {e.Message}"); throw; } }
public BaseResponse <GetSubscriptionResponse> CreateSubscription(CreateSubscriptionRequest request) { var method = HttpMethod.Post; var endpoint = $"/subscriptions"; return(this.HttpClientUtil.SendRequest <GetSubscriptionResponse>(method, endpoint, request)); }
public static Customer CreateCustomerObject(this Customer customer, CreateSubscriptionRequest request, WpUsers user) { customer.BillingAddress = new BillingAddress() { Attention = $"{request.BillingAddress.Fax}", Country = "NG", State = request.BillingState, City = request.BillingCity, Street = request.BillingStreet }; customer.CompanyName = request.CustomerName; //CountryCode = "NG", customer.DisplayName = $"{request.FirstName} {request.LastName}"; //user.DisplayName; customer.Email = user.UserEmail; customer.FirstName = request.FirstName; customer.LastName = request.LastName; customer.ShippingAddress = new ShippingAddress() { Attention = $"{request.ShippingFirstName} {request.ShippingLastName} ,{request.ShippingPhoneNo}", Country = "NG", State = request.ShippingState, City = request.ShippingCity, Street = request.ShippingStreet }; return(customer); }
public async Task <IActionResult> Post(long projectId, [FromBody] CreateSubscriptionRequest request) { _editContext.Subscriptions.Add(new Subscription(projectId, request.Name, request.Phone, request.Email, request.Sum)); await _editContext.SaveAsync(); return(NoContent()); }
public override Task <CreateSubscriptionReply> CreateSubscription(CreateSubscriptionRequest request, ServerCallContext context) { var topic = server.GetTopic(request.TopicName); topic.CreateSubscription(request.SubscriptionName); return(Task.FromResult(new FastQueueService.CreateSubscriptionReply())); }
internal static CreateSubscriptionRequest BuildCreateSubscriptionRequest() { var request = new CreateSubscriptionRequest() { Items = new List <CreateSubscriptionItemRequest>() { new CreateSubscriptionItemRequest() { Description = "Descrição", Quantity = 1, PricingScheme = new CreatePricingSchemeRequest() { Price = 100, SchemeType = "unit" } } }, BillingType = "prepaid", Setup = new CreateSetupRequest() { Amount = 100, Description = "Descrição", Payment = new CreatePaymentRequest() { CreditCard = new CreateCreditCardPaymentRequest() { Capture = true, CreditCardInfo = new CreateCreditCardRequest() { Number = "4556604245849434", HolderName = "VITOR DE ANDRADE", Cvv = "123", ExpMonth = 12, ExpYear = 21, Brand = "Visa", } }, PaymentMethod = "credit_card" } }, Customer = new CreateCustomerRequest() { Name = "Vitor", Email = "*****@*****.**" }, CreditCard = new CreateCreditCardRequest() { Number = "4556604245849434", HolderName = "VITOR DE ANDRADE", Cvv = "123", ExpMonth = 12, ExpYear = 21, Brand = "Visa", }, PaymentMethod = "credit_card" }; return(request); }
/// <summary> /// Initiates the asynchronous execution of the CreateSubscription operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateSubscription 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/CreateSubscription">REST API Reference for CreateSubscription Operation</seealso> public virtual Task <CreateSubscriptionResponse> CreateSubscriptionAsync(CreateSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = CreateSubscriptionRequestMarshaller.Instance; var unmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return(InvokeAsync <CreateSubscriptionRequest, CreateSubscriptionResponse>(request, marshaller, unmarshaller, cancellationToken)); }
/// <summary> /// Initiates the asynchronous execution of the CreateSubscription operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateSubscription operation on AmazonShieldClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSubscription /// operation.</returns> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/shield-2016-06-02/CreateSubscription">REST API Reference for CreateSubscription Operation</seealso> public virtual IAsyncResult BeginCreateSubscription(CreateSubscriptionRequest request, AsyncCallback callback, object state) { var marshaller = new CreateSubscriptionRequestMarshaller(); var unmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return(BeginInvoke <CreateSubscriptionRequest>(request, marshaller, unmarshaller, callback, state)); }
public async Task <IActionResult> AssignSubscription(CreateSubscriptionRequest request) { var subscription = await _subscriptionService.CreateSubscriptionAsync(request); var mapped = _mapper.Map <SubscriptionResponse>(subscription); return(Created("", new ApiOkResponse(mapped))); }
public ActionResult <Subscription> CreateSubscription([FromBody] CreateSubscriptionRequest req) { // Attach payment method PaymentMethod paymentMethod; try { var options = new PaymentMethodAttachOptions { Customer = req.Customer, }; var service = new PaymentMethodService(); paymentMethod = service.Attach(req.PaymentMethod, options); } catch (StripeException e) { return(Ok(new { error = new { message = e.Message } })); } // Update customer's default invoice payment method var customerOptions = new CustomerUpdateOptions { InvoiceSettings = new CustomerInvoiceSettingsOptions { DefaultPaymentMethod = paymentMethod.Id, }, }; var customerService = new CustomerService(); customerService.Update(req.Customer, customerOptions); // Create subscription var subscriptionOptions = new SubscriptionCreateOptions { Customer = req.Customer, Items = new List <SubscriptionItemOptions> { new SubscriptionItemOptions { Price = Environment.GetEnvironmentVariable(req.Price), }, }, }; subscriptionOptions.AddExpand("latest_invoice.payment_intent"); var subscriptionService = new SubscriptionService(); try { Subscription subscription = subscriptionService.Create(subscriptionOptions); return(subscription); } catch (StripeException e) { Console.WriteLine($"Failed to create subscription.{e}"); return(BadRequest()); } }
public async Task <Subscription> CreateSubscriptionAsync(CreateSubscriptionRequest createSubscriptionRequest) { ValidateModel(createSubscriptionRequest); var response = await PostAsJsonAsync("/subscriptions", JsonConvert.SerializeObject(createSubscriptionRequest)).ConfigureAwait(false); return(JsonConvert.DeserializeObject <SubscriptionResponse>( await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Subscription); }
/// <summary> /// 创建订阅 /// </summary> public async Task <CreateSubscriptionResponse> CreateSubscriptionAsync(CreateSubscriptionRequest createSubscriptionRequest) { Dictionary <string, string> urlParam = new Dictionary <string, string>(); string urlPath = HttpUtils.AddUrlPath("/v5/iot/{project_id}/subscriptions", urlParam); SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", createSubscriptionRequest); HttpResponseMessage response = await DoHttpRequestAsync("POST", request); return(JsonUtils.DeSerialize <CreateSubscriptionResponse>(response)); }
internal virtual CreateSubscriptionResponse CreateSubscription(CreateSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return(Invoke <CreateSubscriptionResponse>(request, options)); }
private static async Task <CreateSubscriptionResponse> CreateProductSubscription(string productName, string azureSubscriptionId, string subscriptionDisplayName, string subscriptionId, string resourceGroupName, string serviceName, string token, ILogger log) { // Reference: https://docs.microsoft.com/en-us/rest/api/apimanagement/2019-01-01/subscription/createorupdate // Format the request URI var createSubscriptionUri = $"https://management.azure.com/subscriptions/{azureSubscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{subscriptionId}?api-version=2019-01-01"; // Clear the request headers, set the content type // and add the bearer token. Client.DefaultRequestHeaders.Accept.Clear(); Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); Client.DefaultRequestHeaders.Remove("Authorization"); Client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); // Update the body of the request with the subscription information. // The product subscription ID is already passed into the request as // a parameter, the rest of the data is passed into the body. var requestBody = new CreateSubscriptionRequest { Properties = new Properties { DisplayName = subscriptionDisplayName, Scope = $"/subscriptions/{azureSubscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/products/{productName}" } }; // Serialize and encode the request body var jsonRequest = JsonConvert.SerializeObject(requestBody); var content = new StringContent(jsonRequest, Encoding.UTF8, "application/json"); // Make the request to create the product subscription var response = await Client.PutAsync(createSubscriptionUri, content); var result = await response.Content.ReadAsStringAsync(); // Format the response and return var json = JObject.Parse(result); var createSubscriptionResponse = new CreateSubscriptionResponse { PrimaryKey = json["properties"]["primaryKey"].ToString(), SecondaryKey = json["properties"]["secondaryKey"].ToString() }; return(createSubscriptionResponse); }
public static Plan CreatePlanObject(this Plan plan, CreateSubscriptionRequest request) { plan.BillingCycles = GetCycles(Convert.ToDateTime(request.SubscriptionStartDate, System.Globalization.CultureInfo.CurrentUICulture.DateTimeFormat), Convert.ToDateTime(request.SubscriptionEndDate, System.Globalization.CultureInfo.CurrentUICulture.DateTimeFormat)); //plan.BillingCycles = GetCycles(DateTime.ParseExact(request.SubscriptionStartDate, "dd/MM/yyyy", CultureInfo.InvariantCulture), DateTime.ParseExact(request.SubscriptionEndDate, "dd/MM/yyyy", CultureInfo.InvariantCulture)); plan.PlanCode = request.PlanCode; plan.Quantity = 1; plan.Price = request.Amount; return(plan); }
public async Task CreatesSubscriptionForMerchant() { // given var accessToken = Environment.GetEnvironmentVariable("GoCardlessMerchantAccessToken"); var configuration = ClientConfiguration.ForSandbox(accessToken); var mandatesClient = new MandatesClient(configuration); var mandate = (await mandatesClient.GetPageAsync()).Items.First(); var request = new CreateSubscriptionRequest { Amount = 123, AppFee = 12, Count = 5, Currency = "GBP", Interval = 1, IntervalUnit = IntervalUnit.Weekly, Links = new SubscriptionLinks { Mandate = mandate.Id }, Metadata = new Dictionary <string, string> { ["Key1"] = "Value1", ["Key2"] = "Value2", ["Key3"] = "Value3", }, Name = "Test subscription", StartDate = DateTime.Now.AddMonths(1) }; var subject = new SubscriptionsClient(configuration); // when var result = await subject.CreateAsync(request); // then Assert.That(result.Item.Id, Is.Not.Empty); Assert.That(result.Item.Amount, Is.EqualTo(request.Amount)); Assert.That(result.Item.AppFee, Is.EqualTo(request.AppFee)); Assert.That(result.Item.CreatedAt, Is.Not.Null.And.Not.EqualTo(default(DateTimeOffset))); Assert.That(result.Item.Currency, Is.EqualTo(request.Currency)); Assert.That(result.Item.DayOfMonth, Is.EqualTo(request.DayOfMonth)); Assert.That(result.Item.Interval, Is.EqualTo(request.Interval)); Assert.That(result.Item.IntervalUnit, Is.EqualTo(request.IntervalUnit)); Assert.That(result.Item.Links, Is.Not.Null); Assert.That(result.Item.Links.Mandate, Is.EqualTo(request.Links.Mandate)); Assert.That(result.Item.Metadata, Is.EqualTo(request.Metadata)); Assert.That(result.Item.Month, Is.EqualTo(request.Month)); Assert.That(result.Item.Name, Is.EqualTo(request.Name)); Assert.That(result.Item.PaymentReference, Is.EqualTo(request.PaymentReference)); Assert.That(result.Item.StartDate.Date, Is.EqualTo(request.StartDate.Value.Date)); Assert.That(result.Item.Status, Is.EqualTo(SubscriptionStatus.Active)); Assert.That(result.Item.UpcomingPayments.Count(), Is.EqualTo(request.Count)); }
public ActionResult <SubscriptionResponse> CreateSubscription([FromBody] CreateSubscriptionRequest req) { var customerId = HttpContext.Request.Cookies["customer"]; // Attach payment method PaymentMethod paymentMethod; try { var options = new PaymentMethodAttachOptions { Customer = customerId, }; var service = new PaymentMethodService(); paymentMethod = service.Attach(req.PaymentMethod, options); } catch (StripeException e) { return(BadRequest(new { error = new { message = e.Message } })); } // Create subscription var subscriptionOptions = new SubscriptionCreateOptions { DefaultPaymentMethod = paymentMethod.Id, Customer = customerId, Items = new List <SubscriptionItemOptions> { new SubscriptionItemOptions { Price = Environment.GetEnvironmentVariable(req.Price.ToUpper()), }, }, }; subscriptionOptions.AddExpand("latest_invoice.payment_intent"); var subscriptionService = new SubscriptionService(); try { Subscription subscription = subscriptionService.Create(subscriptionOptions); return(new SubscriptionResponse { Subscription = subscription }); } catch (StripeException e) { Console.WriteLine($"Failed to create subscription.{e}"); return(BadRequest()); } }
/// <summary> /// Receive StateChanged message. /// </summary> /// <param name="state">The service's CommunicationState.</param> public void OnStateChanged(CommunicationState state) { if (state == CommunicationState.Opened) { Task.Run(async() => { try { // create the subscription. var subscriptionRequest = new CreateSubscriptionRequest { RequestedPublishingInterval = this.PublishingInterval, RequestedMaxKeepAliveCount = this.KeepAliveCount, RequestedLifetimeCount = Math.Max(this.LifetimeCount, 3 * this.KeepAliveCount), PublishingEnabled = true, Priority = this.Priority }; var subscriptionResponse = await this.Session.CreateSubscriptionAsync(subscriptionRequest).ConfigureAwait(false); var id = this.Id = subscriptionResponse.SubscriptionId; // add the items. if (this.MonitoredItems.Count > 0) { var items = this.MonitoredItems.ToList(); var requests = items.Select(m => new MonitoredItemCreateRequest { ItemToMonitor = new ReadValueId { NodeId = m.NodeId, AttributeId = m.AttributeId, IndexRange = m.IndexRange }, MonitoringMode = m.MonitoringMode, RequestedParameters = new MonitoringParameters { ClientHandle = m.ClientId, DiscardOldest = m.DiscardOldest, QueueSize = m.QueueSize, SamplingInterval = m.SamplingInterval, Filter = m.Filter } }).ToArray(); var itemsRequest = new CreateMonitoredItemsRequest { SubscriptionId = id, ItemsToCreate = requests, }; var itemsResponse = await this.Session.CreateMonitoredItemsAsync(itemsRequest).ConfigureAwait(false); for (int i = 0; i < itemsResponse.Results.Length; i++) { var item = items[i]; var result = itemsResponse.Results[i]; item.OnCreateResult(result); } } } catch (ServiceResultException ex) { Trace.TraceError($"Subscription error creating subscription '{this.GetType().Name}'. {ex.Message}"); } }); } }
public static LogEntry For(CreateSubscriptionRequest request) { LogEntry entry = new LogEntry("CreateSubscriptionRequest"); entry.Add("RequestHeader", For(request.RequestHeader)); entry.Add("RequestedPublishingInterval", For(request.RequestedPublishingInterval)); entry.Add("RequestedLifetimeCount", For(request.RequestedLifetimeCount)); entry.Add("RequestedMaxKeepAliveCount", For(request.RequestedMaxKeepAliveCount)); entry.Add("MaxNotificationsPerPublish", For(request.MaxNotificationsPerPublish)); entry.Add("PublishingEnabled", For(request.PublishingEnabled)); entry.Add("Priority", For(request.Priority)); return(entry); }
public async Task <ActionResult> CreateSubscriptionAsync([FromBody] CreateSubscriptionRequest request) { try { // EmailHelper.Send("*****@*****.**", "*****@*****.**", "Request Body", JsonConvert //.SerializeObject(request)); } catch (Exception ex) { } return(Ok(await zohoService.CreateSubscriptionAsync(request))); }
public async Task CreatesSubscription() { // given var request = new CreateSubscriptionRequest { Amount = 123, Count = 5, Currency = "GBP", Interval = 1, IntervalUnit = IntervalUnit.Weekly, Links = new SubscriptionLinks { Mandate = _mandate.Id }, Metadata = new Dictionary <string, string> { ["Key1"] = "Value1", ["Key2"] = "Value2", ["Key3"] = "Value3", }, Name = "Test subscription", PaymentReference = "PR123456", StartDate = DateTime.Now.AddMonths(1) }; var subject = new SubscriptionsClient(_clientConfiguration); // when await subject.CreateAsync(request); var result = await subject.CreateAsync(request); // then Assert.That(result.Item.Id, Is.Not.Empty); Assert.That(result.Item.Amount, Is.EqualTo(request.Amount)); Assert.That(result.Item.CreatedAt, Is.Not.Null.And.Not.EqualTo(default(DateTimeOffset))); Assert.That(result.Item.Currency, Is.EqualTo(request.Currency)); Assert.That(result.Item.DayOfMonth, Is.Null); Assert.That(result.Item.Interval, Is.EqualTo(request.Interval)); Assert.That(result.Item.IntervalUnit, Is.EqualTo(request.IntervalUnit)); Assert.That(result.Item.Links, Is.Not.Null); Assert.That(result.Item.Links.Mandate, Is.EqualTo(request.Links.Mandate)); Assert.That(result.Item.Metadata, Is.EqualTo(request.Metadata)); Assert.That(result.Item.Month, Is.Null); Assert.That(result.Item.Name, Is.EqualTo(request.Name)); Assert.That(result.Item.PaymentReference, Is.EqualTo(request.PaymentReference)); Assert.That(result.Item.StartDate.Date, Is.EqualTo(request.StartDate.Value.Date)); Assert.That(result.Item.Status, Is.EqualTo(SubscriptionStatus.Active)); Assert.That(result.Item.UpcomingPayments.Count(), Is.EqualTo(request.Count)); }
public async Task CreateSubscriptionAsync() { var response = new CreateSubscriptionResponse(); var request = new CreateSubscriptionRequest(); var channel = new TestRequestChannel(response); var ret = await channel.CreateSubscriptionAsync(request); ret .Should().BeSameAs(response); channel.Request .Should().BeSameAs(request); }
/// <summary> /// Activates AWS Shield Advanced for an account. /// </summary> /// <param name="request">Container for the necessary parameters to execute the CreateSubscription service method.</param> /// /// <returns>The response from the CreateSubscription service method, as returned by Shield.</returns> /// <exception cref="Amazon.Shield.Model.InternalErrorException"> /// Exception that indicates that a problem occurred with the service infrastructure. /// You can retry the request. /// </exception> /// <exception cref="Amazon.Shield.Model.ResourceAlreadyExistsException"> /// Exception indicating the specified resource already exists. /// </exception> public CreateSubscriptionResponse CreateSubscription(CreateSubscriptionRequest request) { var marshaller = new CreateSubscriptionRequestMarshaller(); var unmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return Invoke<CreateSubscriptionRequest,CreateSubscriptionResponse>(request, marshaller, unmarshaller); }
/// <summary> /// Initializes the message with the body. /// </summary> public CreateSubscriptionMessage(CreateSubscriptionRequest CreateSubscriptionRequest) { this.CreateSubscriptionRequest = CreateSubscriptionRequest; }
/// <summary> /// Initiates the asynchronous execution of the CreateSubscription operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateSubscription operation on AmazonShieldClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSubscription /// operation.</returns> public IAsyncResult BeginCreateSubscription(CreateSubscriptionRequest request, AsyncCallback callback, object state) { var marshaller = new CreateSubscriptionRequestMarshaller(); var unmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return BeginInvoke<CreateSubscriptionRequest>(request, marshaller, unmarshaller, callback, state); }
/// <summary> /// Initiates the asynchronous execution of the CreateSubscription operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateSubscription 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> public Task<CreateSubscriptionResponse> CreateSubscriptionAsync(CreateSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new CreateSubscriptionRequestMarshaller(); var unmarshaller = CreateSubscriptionResponseUnmarshaller.Instance; return InvokeAsync<CreateSubscriptionRequest,CreateSubscriptionResponse>(request, marshaller, unmarshaller, cancellationToken); }
/// <summary> /// Invokes the CreateSubscription service. /// </summary> public virtual ResponseHeader CreateSubscription( RequestHeader requestHeader, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, bool publishingEnabled, byte priority, out uint subscriptionId, out double revisedPublishingInterval, out uint revisedLifetimeCount, out uint revisedMaxKeepAliveCount) { CreateSubscriptionRequest request = new CreateSubscriptionRequest(); CreateSubscriptionResponse response = null; request.RequestHeader = requestHeader; request.RequestedPublishingInterval = requestedPublishingInterval; request.RequestedLifetimeCount = requestedLifetimeCount; request.RequestedMaxKeepAliveCount = requestedMaxKeepAliveCount; request.MaxNotificationsPerPublish = maxNotificationsPerPublish; request.PublishingEnabled = publishingEnabled; request.Priority = priority; UpdateRequestHeader(request, requestHeader == null, "CreateSubscription"); try { if (UseTransportChannel) { IServiceResponse genericResponse = TransportChannel.SendRequest(request); if (genericResponse == null) { throw new ServiceResultException(StatusCodes.BadUnknownResponse); } ValidateResponse(genericResponse.ResponseHeader); response = (CreateSubscriptionResponse)genericResponse; } else { CreateSubscriptionResponseMessage responseMessage = InnerChannel.CreateSubscription(new CreateSubscriptionMessage(request)); if (responseMessage == null || responseMessage.CreateSubscriptionResponse == null) { throw new ServiceResultException(StatusCodes.BadUnknownResponse); } response = responseMessage.CreateSubscriptionResponse; ValidateResponse(response.ResponseHeader); } subscriptionId = response.SubscriptionId; revisedPublishingInterval = response.RevisedPublishingInterval; revisedLifetimeCount = response.RevisedLifetimeCount; revisedMaxKeepAliveCount = response.RevisedMaxKeepAliveCount; } finally { RequestCompleted(request, response, "CreateSubscription"); } return response.ResponseHeader; }
/// <summary> /// Begins an asynchronous invocation of the CreateSubscription service. /// </summary> public IAsyncResult BeginCreateSubscription( RequestHeader requestHeader, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, bool publishingEnabled, byte priority, AsyncCallback callback, object asyncState) { CreateSubscriptionRequest request = new CreateSubscriptionRequest(); request.RequestHeader = requestHeader; request.RequestedPublishingInterval = requestedPublishingInterval; request.RequestedLifetimeCount = requestedLifetimeCount; request.RequestedMaxKeepAliveCount = requestedMaxKeepAliveCount; request.MaxNotificationsPerPublish = maxNotificationsPerPublish; request.PublishingEnabled = publishingEnabled; request.Priority = priority; UpdateRequestHeader(request, requestHeader == null, "CreateSubscription"); if (UseTransportChannel) { return TransportChannel.BeginSendRequest(request, callback, asyncState); } return InnerChannel.BeginCreateSubscription(new CreateSubscriptionMessage(request), callback, asyncState); }