public async Task <FulfillmentRequestResult> UpdateSubscriptionOperationAsync(
Guid subscriptionId,
Guid operationId,
OperationUpdate update,
Guid requestId,
Guid correlationId,
CancellationToken cancellationToken)
{
var requestUrl = FluentUriBuilder
.Start(this.baseUri)
.AddPath("subscriptions")
.AddPath(subscriptionId.ToString())
.AddPath("operations")
.AddPath(operationId.ToString())
.AddQuery(DefaultApiVersionParameterName, this.apiVersion)
.Uri;
requestId = requestId == default ? Guid.NewGuid() : requestId;
correlationId = correlationId == default ? Guid.NewGuid() : correlationId;
var response = await this.SendRequestAndReturnResult(
new HttpMethod("PATCH"),
requestUrl,
requestId,
correlationId,
null,
JsonConvert.SerializeObject(update),
cancellationToken);
return(await FulfillmentRequestResult.ParseAsync <ResolvedSubscription>(response));
}
public void TestExecute()
{
var managerMock = new Mock <InstallationManager>
{
CallBase = true,
};
manager = managerMock.Object;
var operationInstall = new OperationInstall(package.Object);
var operationUninstall = new OperationUninstall(package.Object);
var operationUpdate = new OperationUpdate(package.Object, package.Object);
package.Setup((o) => o.GetPackageType()).Returns("foo");
repository.SetupSequence((o) => o.HasPackage(package.Object))
.Returns(false).Returns(true).Returns(true).Returns(false);
manager.AddInstaller(new InstallerNoop());
manager.Execute(repository.Object, operationInstall);
manager.Execute(repository.Object, operationUninstall);
manager.Execute(repository.Object, operationUpdate);
managerMock.Protected().Verify("Install", Times.Once(), repository.Object, operationInstall);
managerMock.Protected().Verify("Uninstall", Times.Once(), repository.Object, operationUninstall);
managerMock.Protected().Verify("Update", Times.Once(), repository.Object, operationUpdate);
}
public void TestUpdateWithNotEqualPackageType()
{
var initial = new Mock <IPackage>();
initial.Setup((o) => o.GetPackageType()).Returns("foo");
var target = new Mock <IPackage>();
target.Setup((o) => o.GetPackageType()).Returns("bar");
var installerFoo = new Mock <IInstaller>();
installerFoo.Setup((o) => o.IsSupports("foo")).Returns(true);
var installerBar = new Mock <IInstaller>();
installerBar.Setup((o) => o.IsSupports("bar")).Returns(true);
manager.AddInstaller(installerFoo.Object);
manager.AddInstaller(installerBar.Object);
var operationUpdate = new OperationUpdate(initial.Object, target.Object);
manager.Execute(repository.Object, operationUpdate);
installerFoo.Verify((o) => o.Uninstall(repository.Object, initial.Object));
installerBar.Verify((o) => o.Install(repository.Object, target.Object));
}
protected virtual void OnOperationUpdate(OperationType type,
ProgressStyle style) =>
OperationUpdate?.Invoke(this, new OperationUpdateEventArgs
{
Type = type,
Counter = 0,
MaxCount = 0,
Style = style,
StartTime = operationStartTime,
});
protected virtual void OnOperationUpdate(OperationType type,
int counter,
int maxCount) =>
OperationUpdate?.Invoke(this, new OperationUpdateEventArgs
{
Type = type,
Counter = counter,
MaxCount = maxCount,
Style = ProgressStyle.Continuous,
StartTime = operationStartTime,
});
public OpResult Update(String tableName, Dictionary <String, Object> objectMap)
{
if (objectMap == null)
{
throw new ArgumentException(ExceptionMessage.NULL_MAP);
}
TransactionHelper.MakeReferenceToValueFromOpResult(objectMap);
String operationResultId = opResultIdGenerator.GenerateOpResultId(OperationType.UPDATE, tableName);
OperationUpdate operationUpdate = new OperationUpdate(OperationType.UPDATE, tableName, operationResultId, objectMap);
operations.AddLast(operationUpdate);
return(TransactionHelper.MakeOpResult(tableName, operationResultId, OperationType.UPDATE));
}
public async Task NotifyAsync(OperationUpdate notification)
{
using var requestMessage = new HttpRequestMessage(
HttpMethod.Post,
_configuration["SaaSOffer:Connectionwebhook"]);
var json = JsonConvert.SerializeObject(notification);
var httpClient = _httpClientFactory.CreateClient();
requestMessage.Content = new StringContent(json, Encoding.Default, "application/json");
using var response = await httpClient.SendAsync(requestMessage).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
}
public void TestUpdate()
{
var initial = new Mock <IPackage>();
var target = new Mock <IPackage>();
var operationUpdate = new OperationUpdate(initial.Object, target.Object);
initial.Setup((o) => o.GetPackageType()).Returns("foo");
target.Setup((o) => o.GetPackageType()).Returns("foo");
installer.Setup((o) => o.IsSupports("foo")).Returns(true);
manager.AddInstaller(installer.Object);
manager.Execute(repository.Object, operationUpdate);
installer.Verify((o) => o.Download(target.Object, initial.Object));
installer.Verify((o) => o.Update(repository.Object, initial.Object, target.Object));
}
public IActionResult DeleteSubscription([FromRoute] Guid subscriptionId)
{
// create cancel subscription operation
var operation = new OperationUpdate()
{
Id = Guid.NewGuid(),
Action = SaaSActionEnum.Unsubscribe,
SubscriptionId = subscriptionId,
Status = SaasStatusEnum.InProgress
};
// save data in cache.
_cache.Set(operation.Id, operation, _cacheEntryOptions);
_webhookTriggerService.NotifyAsync(operation);
return(StatusCode(202));
}
public IActionResult PatchSubscription([FromRoute] Guid subscriptionId, [FromBody] ChangeQuantityPayload changeQuantityPayload)
{
// create cancel subscription operation
var operation = new OperationUpdate()
{
Id = Guid.NewGuid(),
Action = SaaSActionEnum.ChangeQuantity,
SubscriptionId = subscriptionId,
Quantity = changeQuantityPayload.Quantity,
Status = SaasStatusEnum.InProgress
};
// save data in cache.
_cache.Set(operation.Id, operation, _cacheEntryOptions);
_webhookTriggerService.NotifyAsync(operation);
return(StatusCode(202));
}
public async Task <IActionResult> UpdateSubscription(UpdateSubscriptionViewModel model)
{
var subscription = _dbContext.Subscriptions.Where(
subscription => subscription.Id == model.Subscription.Id).Single();
OperationUpdate operation = null;
// check if the plan is changed
if (model.Subscription.PlanId != subscription.PlanId)
{
// create change plan operation
operation = new OperationUpdate()
{
Id = Guid.NewGuid(),
Action = SaaSActionEnum.ChangePlan,
SubscriptionId = subscription.Id,
Quantity = model.Subscription.Quantity,
Status = SaasStatusEnum.InProgress,
PlanId = model.Subscription.PlanId
};
}
else
{
// create change quantity operation
operation = new OperationUpdate()
{
Id = Guid.NewGuid(),
Action = SaaSActionEnum.ChangeQuantity,
SubscriptionId = subscription.Id,
Quantity = model.Subscription.Quantity,
Status = SaasStatusEnum.InProgress,
PlanId = model.Subscription.PlanId
};
}
model.OperationUpdateId = operation.Id;
// save data in cache
_cache.Set(operation.Id, operation, _cacheEntryOptions);
// webhook trigger: send notifaction to ISV service
await _webhookTriggerService.NotifyAsync(operation);
return(View(model));
}
public async Task <FulfillmentRequestResult> UpdateSubscriptionOperationAsync(
Guid subscriptionId,
Guid operationId,
OperationUpdate update,
Guid requestId,
Guid correlationId,
CancellationToken cancellationToken = default)
{
try
{
var requestUrl = FluentUriBuilder
.Start(_baseUri)
.AddPath("subscriptions")
.AddPath(subscriptionId.ToString())
.AddPath("operations")
.AddPath(operationId.ToString())
.AddQuery(DefaultApiVersionParameterName, _apiVersion)
.Uri;
requestId = requestId == default ? Guid.NewGuid() : requestId;
correlationId = correlationId == default ? Guid.NewGuid() : correlationId;
var bearerToken = await _keyVaultHelper.GetBearerToken(
_options.AzureActiveDirectory,
_options.ClientService.AuthenticationResourceId);
var response = await SendRequestAndReturnResult(
new HttpMethod("PATCH"),
requestUrl,
requestId,
correlationId,
bearerToken,
null,
JsonConvert.SerializeObject(update),
cancellationToken);
return(await FulfillmentRequestResult.ParseAsync <ResolvedSubscriptionResult>(response));
}
catch (LunaServerException e)
{
throw new LunaFulfillmentException($"Cannot update operation {operationId} for subscription {subscriptionId}.", e);
}
}
public async Task <IActionResult> CancelSubscription(UpdateSubscriptionViewModel model)
{
var subscription = _dbContext.Subscriptions.Where(i => i.Id == model.Subscription.Id).Single();
// create cancel subscription operation
var operation = new OperationUpdate()
{
Id = Guid.NewGuid(),
Action = SaaSActionEnum.Unsubscribe,
SubscriptionId = subscription.Id,
Quantity = model.Subscription.Quantity,
Status = SaasStatusEnum.InProgress,
PlanId = model.Subscription.PlanId
};
model.OperationUpdateId = operation.Id;
// save data in cache
_cache.Set(operation.Id, operation, _cacheEntryOptions);
// webhook trigger: send notifaction to ISV service
await _webhookTriggerService.NotifyAsync(operation);
return(View("UpdateSubscription", model));
}
public static OperationHistoryNoSqlEntity Create(OperationUpdate entity) =>
public OperationHistoryEntity(OperationUpdate entity) : base(entity)
{
}
public async Task <Subscription> UpdateOperationCompletedAsync(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.ManualCompleteOperation)
{
_logger.LogInformation($"ManualCompleteOperation of offer {offer.OfferName} is set to true. Will not complete the operation automatically.");
return(await TransitToNextState(subscription, ProvisioningState.ManualCompleteOperationPending));
}
// Don't need to update marketplace operation for delete data
if (!subscription.ProvisioningType.Equals(nameof(ProvisioningType.DeleteData)))
{
Plan plan = await FindPlanById(subscription.PlanId);
OperationUpdate update = new OperationUpdate
{
PlanId = plan.PlanName,
Quantity = subscription.Quantity,
Status = OperationUpdateStatusEnum.Success
};
_logger.LogInformation(
LoggingUtils.ComposeHttpClientLogMessage(
_fulfillmentClient.GetType().Name,
nameof(_fulfillmentClient.UpdateSubscriptionOperationAsync),
subscriptionId));
var result = await _fulfillmentClient.UpdateSubscriptionOperationAsync(
subscriptionId,
subscription.OperationId ?? Guid.Empty,
update,
Guid.NewGuid(),
Guid.NewGuid(),
default);
}
switch (subscription.ProvisioningType)
{
case nameof(ProvisioningType.Update):
case nameof(ProvisioningType.Reinstate):
subscription.Status = nameof(FulfillmentState.Subscribed);
break;
case nameof(ProvisioningType.DeleteData):
subscription.Status = nameof(FulfillmentState.Purged);
break;
case nameof(ProvisioningType.Suspend):
subscription.LastSuspendedTime = DateTime.UtcNow;
subscription.Status = nameof(FulfillmentState.Suspended);
break;
case nameof(ProvisioningType.Unsubscribe):
subscription.UnsubscribedTime = DateTime.UtcNow;
subscription.Status = nameof(FulfillmentState.Unsubscribed);
break;
default:
throw new ArgumentException($"Provisioning type {subscription.ProvisioningType} is not supported.");
}
subscription.ActivatedBy = activatedBy;
return(await TransitToNextState(subscription, ProvisioningState.Succeeded));
}
catch (Exception e)
{
return(await HandleExceptions(subscription, e));
}
}
public AvgPriceUpdate(OperationUpdate entity) : base(entity)
{
EventType = entity.OperationType.ToString();
}
