public virtual async Task <IHttpActionResult> GetRecurringOrderTemplatesPaymentMethodsAsync(GetRecurringOrderTemplatesPaymentMethodsRequest request)
{
var recurringOrderScheduleUrl = RecurringScheduleUrlProvider.GetRecurringScheduleDetailsUrl(new GetRecurringScheduleDetailsUrlParam
{
CultureInfo = ComposerContext.CultureInfo,
RecurringScheduleId = request.Id
});
//TODO : MyWalletPRovider when ready
//var addAddressUrl = MyWalletPRovider.GetAddWAlletUrl(new GetMyAccountUrlParam { CultureInfo = ComposerContext.CultureInfo, ReturnUrl = recurringOrderScheduleUrl });
//var editAddressBaseUrl = MyWalletPRovider.GetUpdateWAlletBaseUrl(new GetMyAccountUrlParam { CultureInfo = ComposerContext.CultureInfo });
var param = new GetPaymentProvidersParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo
};
var providers = await PaymentViewService.GetPaymentProvidersAsync(param).ConfigureAwait(false);
var results = await PaymentViewService.GetCustomerPaymentMethodListViewModelAsync(new GetCustomerPaymentMethodListViewModelParam
{
CustomerId = ComposerContext.CustomerId,
ScopeId = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
ProviderNames = providers.Select(p => p.ProviderName).ToList(),
//walletUrls
}).ConfigureAwait(false);
return(Ok(results));
}
public virtual async Task <IHttpActionResult> UpdateRecurringCartPaymentMethod([FromBody] UpdateRecurringCartPaymentMethodRequest request)
{
if (request == null)
{
return(BadRequest("Request cannot be null."));
}
var param = new GetPaymentProvidersParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo
};
var providers = await PaymentViewService.GetPaymentProvidersAsync(param).ConfigureAwait(false);
var vm = await PaymentViewService.UpdateRecurringOrderCartPaymentMethodAsync(new UpdatePaymentMethodParam
{
CartName = request.CartName,
CultureInfo = ComposerContext.CultureInfo,
CustomerId = ComposerContext.CustomerId,
PaymentId = request.PaymentId.GetValueOrDefault(),
Scope = ComposerContext.Scope,
PaymentMethodId = request.PaymentMethodId.GetValueOrDefault(),
PaymentProviderName = request.PaymentProviderName,
PaymentType = request.PaymentType,
ProviderNames = providers.Select(p => p.ProviderName).ToList(),
IsAuthenticated = ComposerContext.IsAuthenticated
}, RequestUtils.GetBaseUrl(Request).ToString());
return(Ok(vm));
}
public virtual async Task <IHttpActionResult> GetRecurringCartsPaymentMethodsAsync(GetRecurringCartsPaymentMethodsRequest request)
{
var recurringCartUrl = RecurringCartUrlProvider.GetRecurringCartDetailsUrl(new GetRecurringCartDetailsUrlParam
{
CultureInfo = ComposerContext.CultureInfo,
RecurringCartName = request.CartName
});
//TODO : MyWalletPRovider when ready
//var addAddressUrl = MyWalletPRovider.GetAddWAlletUrl(new GetMyAccountUrlParam { CultureInfo = ComposerContext.CultureInfo, ReturnUrl = recurringOrderScheduleUrl });
//var editAddressBaseUrl = MyWalletPRovider.GetUpdateWAlletBaseUrl(new GetMyAccountUrlParam { CultureInfo = ComposerContext.CultureInfo });
//Will need to change Viewmodel returned
var param = new GetPaymentProvidersParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo
};
var providers = await PaymentViewService.GetPaymentProvidersAsync(param).ConfigureAwait(false);
var results = await PaymentViewService.GetPaymentMethodsAsync(new GetPaymentMethodsParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
ProviderNames = providers.Select(p => p.ProviderName).ToList(),
CartName = request.CartName,
CustomerId = ComposerContext.CustomerId,
IsAuthenticated = ComposerContext.IsAuthenticated
});
return(Ok(results));
}
public void When_Passing_Empty_CultureInfo_SHOULD_throw_ArgumentException()
{
// arrange
var param = new GetPaymentProvidersParam
{
Scope = GetRandom.String(32),
CultureInfo = null,
};
var service = _container.CreateInstance <PaymentViewService>();
ConfigureEmptyProviders();
// act & assert
Assert.ThrowsAsync <ArgumentException>(() => service.GetPaymentProvidersAsync(param));
}
public virtual ActionResult CheckoutPayment()
{
var checkoutPaymentViewModel = new CheckoutPaymentViewModel
{
IsLoading = true
};
var getPaymentProvidersParam = new GetPaymentProvidersParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo
};
checkoutPaymentViewModel.Context.Add("PaymentProviders", PaymentViewService.GetPaymentProvidersAsync(getPaymentProvidersParam).Result.ToList());
return(View("CheckoutPaymentContainer", checkoutPaymentViewModel));
}
public async Task WHEN_Passing_Valid_Parameters_SHOULD_Succeed()
{
// arrange
var param = new GetPaymentProvidersParam
{
Scope = GetRandom.String(32),
CultureInfo = CultureInfo.InvariantCulture,
};
var service = _container.CreateInstance <PaymentViewService>();
ConfigureDefaultProviders(param);
// act
var result = await service.GetPaymentProvidersAsync(param);
// assert
result.Should().HaveCount(1);
}
public async Task WHEN_Provider_Not_Active_SHOULD_Filter_out_value()
{
// arrange
var param = new GetPaymentProvidersParam
{
Scope = GetRandom.String(32),
CultureInfo = CultureInfo.InvariantCulture,
};
var service = _container.CreateInstance <PaymentViewService>();
var(provider, _) = ConfigureDefaultProviders(param);
provider.IsActive = false;
// act
var result = await service.GetPaymentProvidersAsync(param);
// assert
result.Should().HaveCount(0);
}
public async Task WHEN_Culture_not_supported_SHOULD_Filter_out_value()
{
// arrange
var param = new GetPaymentProvidersParam
{
Scope = GetRandom.String(32),
CultureInfo = new CultureInfo("en-US"),
};
var service = _container.CreateInstance <PaymentViewService>();
var(_, paymentProvider) = ConfigureDefaultProviders(param);
paymentProvider.SupportedCultureIds = "ua-UK";
// act
var result = await service.GetPaymentProvidersAsync(param);
// assert
result.Should().HaveCount(0);
}
private (Provider provider, PaymentProvider paymentProvider) ConfigureDefaultProviders(GetPaymentProvidersParam param)
{
var localPaymentProvider = new FakePaymentProvider();
_paymentProviderMoq
.Setup(q => q.ResolveAllProviders())
.Returns(new List <IPaymentProvider> {
localPaymentProvider
});
var id = Guid.NewGuid();
var provider = new Provider
{
Id = id,
ImplementationTypeName = localPaymentProvider.ProviderType,
IsActive = true,
};
var paymentProvider = new PaymentProvider
{
Id = id,
SupportedCultureIds = param.CultureInfo.Name,
};
_paymentRepoMoq
.Setup(q => q.GetProviders(It.IsAny <string>(), ProviderType.Payment))
.ReturnsAsync(new List <Provider>
{
provider
});
_paymentRepoMoq
.Setup(q => q.GetPaymentProviders(It.IsAny <string>()))
.ReturnsAsync(new List <PaymentProvider>
{
paymentProvider,
});
return(provider, paymentProvider);
}
/// <summary>
/// Gets an enumeration of all available payment providers.
/// </summary>
/// <param name="param">Parameters used to retrieve the payment providers.</param>
/// <returns></returns>
public virtual async Task <IEnumerable <PaymentProviderViewModel> > GetPaymentProvidersAsync(GetPaymentProvidersParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage(nameof(param.CultureInfo)), nameof(param));
}
if (param.Scope == null)
{
throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage(nameof(param.Scope)), nameof(param));
}
var providers = PaymentProviderFactory.ResolveAllProviders();
providers = await FilterAvailablePaymentProviders(param, providers).ConfigureAwait(false);
var viewModels = new List <PaymentProviderViewModel>();
foreach (var paymentProvider in providers)
{
var vm = MapPaymentProviderViewModel(paymentProvider, param.CultureInfo);
viewModels.Add(vm);
}
return(viewModels);
}
protected virtual async Task <IEnumerable <IPaymentProvider> > FilterAvailablePaymentProviders(GetPaymentProvidersParam param, IEnumerable <IPaymentProvider> providers)
{
var availablePaymentProvidersTask = PaymentRepository.GetPaymentProviders(param.Scope).ConfigureAwait(false);
var availableProvidersTask = PaymentRepository.GetProviders(param.Scope, ProviderType.Payment);
var availablePaymentProviders = await availablePaymentProvidersTask;
var availableProviders = await availableProvidersTask;
var result = new List <IPaymentProvider>();
foreach (var provider in providers)
{
var availableProvider = availableProviders
.Where(p => p.ImplementationTypeName.Equals(provider.ProviderType, StringComparison.OrdinalIgnoreCase))
.Where(p => p.IsActive)
.FirstOrDefault();
if (availableProvider == null)
{
continue;
}
var availablePaymentProvider = availablePaymentProviders
.Where(p => p.Id == availableProvider.Id)
.FirstOrDefault();
if (availablePaymentProvider == null)
{
continue;
}
var supportedCultureIds = availablePaymentProvider.SupportedCultureIds.Split(',').Select(c => c.Trim());
if (!supportedCultureIds.Any(c => c.Equals(param.CultureInfo.Name, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
result.Add(provider);
}
return(result);
}
protected virtual async Task <IEnumerable <IPaymentProvider> > FilterAvailablePaymentProviders(GetPaymentProvidersParam param, IEnumerable <IPaymentProvider> providers)
{
var availablePaymentProvidersTask = PaymentRepository.GetPaymentProviders(param.Scope).ConfigureAwait(false);
var availableProvidersTask = PaymentRepository.GetProviders(param.Scope, ProviderType.Payment);
var availablePaymentProviders = await availablePaymentProvidersTask;
var availableProviders = await availableProvidersTask;
var availableProvidersDic = new Dictionary <string, Overture.ServiceModel.Providers.Provider>(StringComparer.OrdinalIgnoreCase);
foreach (var el in availableProviders)
{
if (!el.IsActive || availableProvidersDic.ContainsKey(el.ImplementationTypeName))
{
continue;
}
availableProvidersDic.Add(el.ImplementationTypeName, el);
}
var availablePaymentProvidersDic = new Dictionary <Guid, Overture.ServiceModel.Providers.PaymentProvider>();
foreach (var el in availablePaymentProviders)
{
if (availablePaymentProvidersDic.ContainsKey(el.Id))
{
continue;
}
availablePaymentProvidersDic.Add(el.Id, el);
}
var result = new List <IPaymentProvider>();
foreach (var provider in providers)
{
availableProvidersDic.TryGetValue(provider.ProviderType, out var availableProvider);
if (availableProvider == null)
{
continue;
}
availablePaymentProvidersDic.TryGetValue(availableProvider.Id, out var availablePaymentProvider);
if (availablePaymentProvider == null)
{
continue;
}
var supportedCultureIds = availablePaymentProvider.SupportedCultureIds.Split(',').Select(c => c.Trim());
if (!supportedCultureIds.Any(c => c.Equals(param.CultureInfo.Name, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
result.Add(provider);
}
return(result);
}
