/// <summary>
/// Resolves a subscription with Azure Marketplace given a token
/// </summary>
/// <param name="authCode">The authentication code for the subscription</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <MarketplaceSubscription> ResolveSubscriptionAsync(
string authCode,
CancellationToken cancellationToken = default)
{
try
{
_logger.LogInformation(
LoggingUtils.ComposeHttpClientLogMessage(
_fulfillmentClient.GetType().Name,
nameof(_fulfillmentClient.ResolveSubscriptionAsync)));
Guid requestId = Guid.NewGuid();
Guid correlationId = Guid.NewGuid();
ResolvedSubscriptionResult subscription = await _fulfillmentClient.ResolveSubscriptionAsync(
authCode,
requestId,
correlationId,
cancellationToken);
_logger.LogInformation(
LoggingUtils.ComposeSubscriptionActionMessage(
"Resolved",
subscription.SubscriptionId,
subscription.PlanId,
subscription.Quantity.ToString()));
return(MarketplaceSubscription.From(subscription, StatusEnum.Provisioning));
}
catch (Exception e)
{
var errorMessage = "The token is invalid.";
throw new LunaFulfillmentException(errorMessage, e);
}
}
public async Task <Subscription> ActivateSubscriptionAsync(Guid subscriptionId, string activatedBy = "system")
{
Subscription subscription = await _context.Subscriptions.FindAsync(subscriptionId);
ValidateSubscriptionAndInputState(subscription);
try
{
Offer offer = await FindOfferById(subscription.OfferId);
if (subscription.ProvisioningStatus.Equals(ProvisioningState.NotificationPending.ToString(), StringComparison.InvariantCultureIgnoreCase) &&
offer.ManualActivation)
{
_logger.LogInformation($"ManualActivation of offer {offer.OfferName} is set to true. Will not activate the subscription.");
return(await TransitToNextState(subscription, ProvisioningState.ManualActivationPending));
}
Plan plan = await FindPlanById(subscription.PlanId);
ActivatedSubscriptionResult activatedResult = new ActivatedSubscriptionResult
{
PlanId = plan.PlanName,
Quantity = subscription.Quantity.ToString()
};
_logger.LogInformation(
LoggingUtils.ComposeHttpClientLogMessage(
_fulfillmentClient.GetType().Name,
nameof(_fulfillmentClient.ActivateSubscriptionAsync),
subscriptionId));
var result = await _fulfillmentClient.ActivateSubscriptionAsync(
subscriptionId,
activatedResult,
Guid.NewGuid(),
Guid.NewGuid(),
default);
_logger.LogInformation(
LoggingUtils.ComposeSubscriptionActionMessage(
"Activated",
subscriptionId,
activatedResult.PlanId,
activatedResult.Quantity,
activatedBy));
await _subscriptionCustomMeterUsageService.EnableSubscriptionCustomMeterUsageBySubscriptionId(subscriptionId);
subscription.Status = nameof(FulfillmentState.Subscribed);
subscription.ActivatedTime = DateTime.UtcNow;
subscription.ActivatedBy = activatedBy;
return(await TransitToNextState(subscription, ProvisioningState.Succeeded));
}
catch (Exception e)
{
return(await HandleExceptions(subscription, e));
}
}
/// <summary>
/// Update a subscription
/// </summary>
/// <param name="subscriptionId">The subscription id</param>
/// <param name="planId">The plan id</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <FulfillmentManagerOperationResult> RequestUpdateSubscriptionAsync(
Guid subscriptionId,
string planId,
CancellationToken cancellationToken = default)
{
try
{
_logger.LogInformation(
LoggingUtils.ComposeHttpClientLogMessage(
_fulfillmentClient.GetType().Name,
nameof(_fulfillmentClient.UpdateSubscriptionAsync),
subscriptionId));
Guid requestId = Guid.NewGuid();
Guid correlationId = Guid.NewGuid();
ActivatedSubscriptionResult activatedSubscription = new ActivatedSubscriptionResult {
PlanId = planId
};
UpdateOrDeleteSubscriptionRequestResult response = await _fulfillmentClient.UpdateSubscriptionAsync(
subscriptionId,
activatedSubscription,
requestId,
correlationId,
cancellationToken);
_logger.LogInformation(
LoggingUtils.ComposeSubscriptionActionMessage(
"Updated",
subscriptionId,
activatedSubscription.PlanId,
activatedSubscription.Quantity));
SubscriptionOperation operation = await _fulfillmentClient.GetSubscriptionOperationAsync(
subscriptionId,
response.OperationId,
requestId,
correlationId,
cancellationToken);
FulfillmentManagerOperationResult returnResult = FulfillmentManagerOperationResult.Success;
returnResult.Operation = operation;
return(returnResult);
}
catch (Exception e)
{
var errorMessage = $"Cannot update subscription {subscriptionId}.";
throw new LunaFulfillmentException(errorMessage, e);
}
}
/// <summary>
/// Activate a subscription
/// </summary>
/// <param name="subscriptionId">The subscription id</param>
/// <param name="planId">The plan id</param>
/// <param name="quantity">The quantity</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <MarketplaceSubscription> ActivateSubscriptionAsync(
Guid subscriptionId,
string planId,
int?quantity,
CancellationToken cancellationToken = default)
{
Guid requestId = Guid.NewGuid();
Guid correlationId = Guid.NewGuid();
var subscriptionToBeActivated = new ActivatedSubscriptionResult {
PlanId = planId
};
if (quantity.HasValue)
{
subscriptionToBeActivated.Quantity = quantity.Value.ToString();
}
try
{
_logger.LogInformation(
LoggingUtils.ComposeHttpClientLogMessage(
_fulfillmentClient.GetType().Name,
nameof(_fulfillmentClient.ActivateSubscriptionAsync),
subscriptionId));
var result = await _fulfillmentClient.ActivateSubscriptionAsync(
subscriptionId,
subscriptionToBeActivated,
requestId,
correlationId,
cancellationToken);
_logger.LogInformation(
LoggingUtils.ComposeSubscriptionActionMessage(
"Activated",
subscriptionId,
planId,
quantity.ToString()));
var returnValue = new MarketplaceSubscription
{
PlanId = planId,
State = StatusEnum.Subscribed,
SubscriptionId = subscriptionId
};
if (quantity.HasValue)
{
returnValue.Quantity = quantity.Value;
}
return(returnValue);
}
catch (Exception e)
{
var errorMessage = LoggingUtils.ComposeSubscriptionActionMessage(
"Failed to activate",
subscriptionId,
planId,
quantity.ToString());
throw new LunaFulfillmentException(errorMessage, e);
}
}
