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