public async Task CancelsSubscription()
{
// given
var subscription = await _resourceFactory.CreateSubscriptionFor(_mandate);
var request = new CancelSubscriptionRequest
{
Id = subscription.Id,
Metadata = new Dictionary <string, string>
{
["Key4"] = "Value4",
["Key5"] = "Value5",
["Key6"] = "Value6",
},
};
var subject = new SubscriptionsClient(_clientConfiguration);
// when
var result = await subject.CancelAsync(request);
// then
Assert.That(result.Item.Id, Is.EqualTo(request.Id));
Assert.That(result.Item.Status, Is.EqualTo(SubscriptionStatus.Cancelled));
}
public async Task ReturnsAllSubscriptions()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
// when
var result = await subject.GetPageAsync();
var actual = result.Items.ToList();
// then
Assert.That(actual.Any(), Is.True);
Assert.That(result.Meta.Limit, Is.Not.EqualTo(0));
Assert.That(actual.Count, Is.LessThanOrEqualTo(result.Meta.Limit));
Assert.That(actual[0], Is.Not.Null);
Assert.That(actual[0].Id, Is.Not.Null);
Assert.That(actual[0].Amount, Is.Not.EqualTo(default(int)));
Assert.That(actual[0].AppFee, Is.Null);
Assert.That(actual[0].CreatedAt, Is.Not.Null.And.Not.EqualTo(default(DateTimeOffset)));
Assert.That(actual[0].Currency, Is.Not.Null);
Assert.That(actual[0].Interval, Is.Not.Null);
Assert.That(actual[0].IntervalUnit, Is.Not.Null);
Assert.That(actual[0].Links, Is.Not.Null);
Assert.That(actual[0].Links.Mandate, Is.Not.Null);
Assert.That(actual[0].Metadata, Is.Not.Null);
Assert.That(actual[0].Name, Is.Not.Null);
Assert.That(actual[0].PaymentReference, Is.Not.Null);
Assert.That(actual[0].StartDate, Is.Not.Null.And.Not.EqualTo(default(DateTime)));
Assert.That(actual[0].Status, Is.Not.Null);
Assert.That(actual[0].UpcomingPayments, Is.Not.Null);
Assert.That(actual[0].UpcomingPayments.Any(), Is.True);
}
public async Task MapsPagingProperties()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var firstPageRequest = new GetSubscriptionsRequest
{
Limit = 1
};
// when
var firstPageResult = await subject.GetPageAsync(firstPageRequest);
var secondPageRequest = new GetSubscriptionsRequest
{
After = firstPageResult.Meta.Cursors.After,
Limit = 2
};
var secondPageResult = await subject.GetPageAsync(secondPageRequest);
// then
Assert.That(firstPageResult.Items.Count(), Is.EqualTo(firstPageRequest.Limit));
Assert.That(firstPageResult.Meta.Limit, Is.EqualTo(firstPageRequest.Limit));
Assert.That(firstPageResult.Meta.Cursors.Before, Is.Null);
Assert.That(firstPageResult.Meta.Cursors.After, Is.Not.Null);
Assert.That(secondPageResult.Items.Count(), Is.EqualTo(secondPageRequest.Limit));
Assert.That(secondPageResult.Meta.Limit, Is.EqualTo(secondPageRequest.Limit));
Assert.That(secondPageResult.Meta.Cursors.Before, Is.Not.Null);
Assert.That(secondPageResult.Meta.Cursors.After, Is.Not.Null);
}
public async Task ReturnsIndividualSubscription()
{
// given
var subscription = await _resourceFactory.CreateSubscriptionFor(_mandate);
var subject = new SubscriptionsClient(_clientConfiguration);
// when
var result = await subject.ForIdAsync(subscription.Id);
// then
Assert.That(result.Item.Id, Is.EqualTo(subscription.Id));
Assert.That(result.Item.Amount, Is.Not.Null.And.EqualTo(subscription.Amount));
Assert.That(result.Item.CreatedAt, Is.Not.Null.And.Not.EqualTo(default(DateTimeOffset)));
Assert.That(result.Item.Currency, Is.Not.Null.And.EqualTo(subscription.Currency));
Assert.That(result.Item.Interval, Is.Not.Null.And.EqualTo(subscription.Interval));
Assert.That(result.Item.IntervalUnit, Is.Not.Null.And.EqualTo(subscription.IntervalUnit));
Assert.That(result.Item.Links, Is.Not.Null);
Assert.That(result.Item.Links.Mandate, Is.Not.Null.And.EqualTo(subscription.Links.Mandate));
Assert.That(result.Item.Metadata, Is.Not.Null.And.EqualTo(subscription.Metadata));
Assert.That(result.Item.Name, Is.Not.Null.And.EqualTo(subscription.Name));
Assert.That(result.Item.PaymentReference, Is.Not.Null.And.EqualTo(subscription.PaymentReference));
Assert.That(result.Item.StartDate, Is.Not.Null.And.EqualTo(subscription.StartDate));
Assert.That(result.Item.Status, Is.Not.Null.And.EqualTo(subscription.Status));
Assert.That(result.Item.UpcomingPayments, Is.Not.Null);
Assert.That(result.Item.UpcomingPayments.Count(), Is.EqualTo(subscription.UpcomingPayments.Count()));
}
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 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));
}
protected override async Task OnInitializedAsync()
{
await SubscriptionsClient.CreateAsync(_subscriptionStream, _channel,
new PersistentSubscriptionSettings(resolveLinkTos : true), Credentials);
await SubscriptionsClient.SubscribeAsync(
_subscriptionStream,
_channel, eventAppeared :
OnEventAppeared, OnSubscriptionDropped);
}
static async System.Threading.Tasks.Task Main(string[] args)
{
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("https://fastreport.cloud");
httpClient.DefaultRequestHeaders.Authorization = new FastReportCloudApiKeyHeader(ApiKey);
var subscriptions = new SubscriptionsClient(httpClient);
var rpClientTemplates = new TemplatesClient(httpClient);
var rpClientExports = new ExportsClient(httpClient);
var downloadClient = new DownloadClient(httpClient);
var subscription = (await subscriptions.GetSubscriptionsAsync(0, 10)).Subscriptions.First();
var templateFolder = subscription.TemplatesFolder.FolderId;
var exportFolder = subscription.ExportsFolder.FolderId;
TemplateCreateVM templateCreateVM = new TemplateCreateVM()
{
Name = "box.frx",
Content = TestData.BoxReport
};
TemplateVM uploadedFile = await rpClientTemplates.UploadFileAsync(templateFolder, templateCreateVM);
ExportTemplateTaskVM export = new ExportTemplateTaskVM()
{
FileName = "box.pdf",
FolderId = exportFolder,
Format = ExportTemplateTaskVMFormat.Pdf
};
ExportVM exportedFile = await rpClientTemplates.ExportAsync(uploadedFile.Id, export) as ExportVM;
string fileId = exportedFile.Id;
int attempts = 3;
exportedFile = rpClientExports.GetFile(fileId);
while (exportedFile.Status != ExportVMStatus.Success && attempts >= 0)
{
await Task.Delay(1000);
exportedFile = rpClientExports.GetFile(fileId);
attempts--;
}
using (var file = await downloadClient.GetExportAsync(fileId))
{
using (var pdf = File.Open("report.pdf", FileMode.Create))
{
file.Stream.CopyTo(pdf);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Subscriptions"/> class.
/// </summary>
/// <param name="client">The <see cref="SubscriptionsClient"/> to use for connecting to the Runtime.</param>
/// <param name="executionContextManager">The <see cref="IExecutionContextManager"/> to use for getting the current <see cref="Execution.ExecutionContext"/>.</param>
/// <param name="head">The current <see cref="Head"/>.</param>
/// <param name="logger">The <see cref="ILogger"/> to use for logging.</param>
public Subscriptions(
SubscriptionsClient client,
IExecutionContextManager executionContextManager,
Head head,
ILogger logger)
{
_client = client;
_executionContextManager = executionContextManager;
_head = head;
_logger = logger;
}
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 async void GetSubscription()
{
var str = File.ReadAllText("scp682");
client.DefaultRequestHeaders.Authorization = new FastReportCloudApiKeyHeader(str);
httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("https://fastreport.cloud");
httpClient.DefaultRequestHeaders.Authorization = new FastReportCloudApiKeyHeader(str);
var subscriptions = new SubscriptionsClient(httpClient);
subscription = (await subscriptions.GetSubscriptionsAsync(0, 2)).Subscriptions.First();
}
public async Task CallsGetSubscriptionsEndpoint()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
// when
await subject.GetPageAsync();
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/subscriptions")
.WithVerb(HttpMethod.Get);
}
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 void IdIsNullOrWhiteSpaceThrows(string id)
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
// when
AsyncTestDelegate test = () => subject.ForIdAsync(id);
// then
var ex = Assert.ThrowsAsync <ArgumentException>(test);
Assert.That(ex.Message, Is.Not.Null);
Assert.That(ex.ParamName, Is.EqualTo(nameof(id)));
}
public async Task CallsIndividualSubscriptionsEndpoint()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var id = "SB12345678";
// when
await subject.ForIdAsync(id);
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/subscriptions/SB12345678")
.WithVerb(HttpMethod.Get);
}
public void CreateSubscriptionRequestIsNullThrows()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
CreateSubscriptionRequest request = null;
// when
AsyncTestDelegate test = () => subject.CreateAsync(request);
// then
var ex = Assert.ThrowsAsync <ArgumentNullException>(test);
Assert.That(ex.ParamName, Is.EqualTo(nameof(request)));
}
public void CancelSubscriptionRequestIdIsNullOrWhiteSpaceThrows(string id)
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var request = new CancelSubscriptionRequest
{
Id = id
};
// when
AsyncTestDelegate test = () => subject.CancelAsync(request);
// then
var ex = Assert.ThrowsAsync <ArgumentException>(test);
Assert.That(ex.ParamName, Is.EqualTo(nameof(request.Id)));
}
public async Task CallsCancelSubscriptionEndpoint()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var request = new CancelSubscriptionRequest
{
Id = "SB12345678"
};
// when
await subject.CancelAsync(request);
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/subscriptions/SB12345678/actions/cancel")
.WithVerb(HttpMethod.Post);
}
public async Task CallsCreateSubscriptionEndpoint()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var request = new CreateSubscriptionRequest
{
IdempotencyKey = Guid.NewGuid().ToString()
};
// when
await subject.CreateAsync(request);
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/subscriptions")
.WithHeader("Idempotency-Key")
.WithVerb(HttpMethod.Post);
}
public async Task CallsGetSubscriptionsEndpointUsingRequest()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var request = new GetSubscriptionsRequest
{
Before = "before test",
After = "after test",
Limit = 5
};
// when
await subject.GetPageAsync(request);
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/subscriptions?before=before%20test&after=after%20test&limit=5")
.WithVerb(HttpMethod.Get);
}
public void ApiUsageIsInvalidInvalidThrows()
{
// given
var request = new CreateSubscriptionRequest
{
Amount = 123,
Currency = "GBP",
IntervalUnit = IntervalUnit.Weekly,
Count = 5,
Interval = 1,
Metadata = new Dictionary <string, string>
{
["Key1"] = "Value1",
["Key2"] = "Value2",
["Key3"] = "Value3",
},
Name = "Test subscription",
StartDate = DateTime.Now.AddMonths(1),
Links = new SubscriptionLinks
{
Mandate = _mandate.Id
}
};
var subject = new SubscriptionsClient(ClientConfiguration.ForSandbox("invalid token"));
// when
AsyncTestDelegate test = () => subject.CreateAsync(request);
// then
var ex = Assert.ThrowsAsync <InvalidApiUsageException>(test);
Assert.That(ex.Code, Is.EqualTo((int)HttpStatusCode.Unauthorized));
Assert.That(ex.DocumentationUrl, Is.Not.Null);
Assert.That(ex.Errors?.Any(), Is.True);
Assert.That(ex.Message, Is.Not.Null.And.Not.Empty);
Assert.That(ex.RawResponse, Is.Not.Null.And.Not.Empty);
Assert.That(ex.RequestId, Is.Not.Null.And.Not.Empty);
}
public GoCardlessClient(ClientConfiguration configuration)
{
_configuration = configuration;
BankDetailsLookups = new BankDetailsLookupsClient(configuration);
CreditorBankAccounts = new CreditorBankAccountsClient(configuration);
Creditors = new CreditorsClient(configuration);
CustomerBankAccounts = new CustomerBankAccountsClient(configuration);
CustomerNotifications = new CustomerNotificationsClient(configuration);
Customers = new CustomersClient(configuration);
Events = new EventsClient(configuration);
MandateImportEntries = new MandateImportEntriesClient(configuration);
MandateImports = new MandateImportsClient(configuration);
MandatePdfs = new MandatePdfsClient(configuration);
Mandates = new MandatesClient(configuration);
Payments = new PaymentsClient(configuration);
PayoutItems = new PayoutItemsClient(configuration);
Payouts = new PayoutsClient(configuration);
RedirectFlows = new RedirectFlowsClient(configuration);
Refunds = new RefundsClient(configuration);
Subscriptions = new SubscriptionsClient(configuration);
}
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));
}
public async Task PagesThroughSubscriptions()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var firstId = (await subject.GetPageAsync()).Items.First().Id;
var initialRequest = new GetSubscriptionsRequest
{
After = firstId,
CreatedGreaterThan = new DateTimeOffset(DateTime.Now.AddDays(-1)),
Limit = 1,
};
// when
var result = await subject
.BuildPager()
.StartFrom(initialRequest)
.AndGetAllAfterAsync();
// then
Assert.That(result.Count, Is.GreaterThan(1));
Assert.That(result[0].Id, Is.Not.Null.And.Not.EqualTo(result[1].Id));
Assert.That(result[1].Id, Is.Not.Null.And.Not.EqualTo(result[0].Id));
}
/// <summary>
/// Lists all geo-locations.
/// </summary>
/// <param name="subscriptionId"> The Id of the target subscription. </param>
/// <param name="token"> A token to allow the caller to cancel the call to the service. The default value is <see cref="P:System.Threading.CancellationToken.None" />. </param>
/// <returns> An async collection of location data that may take multiple service requests to iterate over. </returns>
/// <exception cref="InvalidOperationException"> <paramref name="subscriptionId"/> is null. </exception>
public AsyncPageable <LocationData> ListLocationsAsync(string subscriptionId = null, CancellationToken token = default(CancellationToken))
{
async Task <AsyncPageable <LocationData> > PageableFunc()
{
if (string.IsNullOrWhiteSpace(subscriptionId))
{
subscriptionId = await GetDefaultSubscription(token);
if (subscriptionId == null)
{
throw new InvalidOperationException("Please select a default subscription");
}
}
return(new PhWrappingAsyncPageable <Azure.ResourceManager.Resources.Models.Location, LocationData>(SubscriptionsClient.ListLocationsAsync(subscriptionId, token), s => new LocationData(s)));
}
return(new PhTaskDeferringAsyncPageable <LocationData>(PageableFunc));
}
static void RunSubscriptionsClient(IMundiAPIClient client)
{
//Criação + Consulta (plano)
Console.WriteLine("Criação + Consulta (plano)");
var subscriptionId = SubscriptionsClient.CreateSubscriptionByPlan(client);
SubscriptionsClient.GetSubscription(client, subscriptionId);
//Criação (avulsa)
Console.WriteLine("Criação + Consulta (avulsa)");
SubscriptionsClient.CreateSubscription(client);
//Adicionar item + Atualizar item
Console.WriteLine("Adicionar item + Atualizar item");
var subscriptionItemId = SubscriptionsClient.CreateSubscriptionItem(client, subscriptionId);
SubscriptionsClient.UpdateSubscriptionItem(client, subscriptionId, subscriptionItemId);
//Adicionar uso
Console.WriteLine("Adicionar uso");
var usageId = SubscriptionsClient.CreateUsage(client, subscriptionId, subscriptionItemId);
//Remover uso
Console.WriteLine("Remover uso");
SubscriptionsClient.DeleteUsage(client, subscriptionId, subscriptionItemId, usageId);
//Listar uso
Console.WriteLine("Listar uso");
SubscriptionsClient.GetUsages(client, subscriptionId, subscriptionItemId);
//Incluir desconto (item)
Console.WriteLine("Incluir desconto (item)");
SubscriptionsClient.CreateDiscountOnItem(client, subscriptionId, subscriptionItemId);
//Incluir desconto (assinatura)
Console.WriteLine("Incluir desconto (assinatura)");
var discountId = SubscriptionsClient.CreateDiscount(client, subscriptionId);
//Remover desconto
Console.WriteLine("Remover desconto");
SubscriptionsClient.DeleteDiscount(client, subscriptionId, discountId);
//Remover item
Console.WriteLine("Remover item");
SubscriptionsClient.DeleteSubscriptionItem(client, subscriptionId, subscriptionItemId);
//Listar itens
Console.WriteLine("Listar itens");
SubscriptionsClient.GetSubscriptionItems(client, subscriptionId);
//Atualizar cartão
Console.WriteLine("Atualizar cartão");
SubscriptionsClient.UpdateSubscriptionCreditCard(client, subscriptionId);
//Atualizar meio de pagamento
Console.WriteLine("Atualizar meio de pagamento");
SubscriptionsClient.UpdateSubscriptionPaymentMethod(client, subscriptionId);
//Atualizar data de faturamento
Console.WriteLine("Atualizar data de faturamento");
SubscriptionsClient.UpdateSubscriptionBillingDate(client, subscriptionId);
//Consultar faturas
Console.WriteLine("Consultar faturas");
subscriptionId = SubscriptionsClient.CreateSubscription(client);
SubscriptionsClient.GetSubscriptionInvoices(client, subscriptionId);
//Listagem
Console.WriteLine("Listagem");
SubscriptionsClient.GetSubscriptions(client);
//Exclusão
Console.WriteLine("Exclusão");
SubscriptionsClient.DeleteSubscription(client, subscriptionId);
}
/// <summary>
/// Lists all geo-locations.
/// </summary>
/// <param name="subscriptionId"> The Id of the target subscription. </param>
/// <param name="cancellationToken"> A token to allow the caller to cancel the call to the service. The default value is <see cref="P:System.Threading.CancellationToken.None" />. </param>
/// <returns> A collection of location data that may take multiple service requests to iterate over. </returns>
/// <exception cref="InvalidOperationException"> <paramref name="subscriptionId"/> is null. </exception>
public Pageable <LocationData> ListLocations(string subscriptionId = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (string.IsNullOrWhiteSpace(subscriptionId))
{
subscriptionId = GetDefaultSubscription(cancellationToken).ConfigureAwait(false).GetAwaiter().GetResult();
if (subscriptionId == null)
{
throw new InvalidOperationException("Please select a default subscription");
}
}
return(new PhWrappingPageable <Azure.ResourceManager.Resources.Models.Location, LocationData>(SubscriptionsClient.ListLocations(subscriptionId, cancellationToken), s => new LocationData(s)));
}
