public void When_Passing_null_Scope_SHOULD_throw_ArgumentException()
{
//Arrange
var paymentMethods = new List <PaymentMethod> {
new PaymentMethod()
};
MockFindCartPaymentMethodsRequest(paymentMethods);
var repository = _container.CreateInstance <PaymentRepository>();
var param = new GetPaymentMethodsParam
{
CartName = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
ProviderNames = new List <string> {
GetRandom.String(7), GetRandom.String(7)
},
Scope = null,
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => repository.GetPaymentMethodsAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("Scope");
}
public async Task When_Overture_Return_Empty_List_SHOULD_Not_Throw()
{
//Arrange
var paymentMethods = new List <PaymentMethod> {
new PaymentMethod()
};
MockFindCartPaymentMethodsRequest(paymentMethods);
//Act
var param = new GetPaymentMethodsParam
{
CartName = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
ProviderNames = new List <string> {
GetRandom.String(7), GetRandom.String(7)
},
Scope = GetRandom.String(32),
};
var repository = _container.CreateInstance <PaymentRepository>();
var result = await repository.GetPaymentMethodsAsync(param).ConfigureAwait(false);
//Assert
result.Should().NotBeNull();
}
/// <summary>
/// Get the Payment methods available for a cart.
/// </summary>
/// <param name="param">GetPaymentMethodsParam</param>
/// <returns>A List of PaymentMethod</returns>
public virtual async Task <List <PaymentMethod> > GetPaymentMethodsAsync(GetPaymentMethodsParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (string.IsNullOrWhiteSpace(param.CartName))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.CartName)), nameof(param));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param));
}
if (param.ProviderNames == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ProviderNames)), nameof(param));
}
if (!param.ProviderNames.Any())
{
return(new List <PaymentMethod>());
}
var tasks = param.ProviderNames.Select(pName => GetPaymentMethodForProviderAsync(param, pName)).ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
var methods = tasks.SelectMany(t => t.Result).ToList();
return(methods);
}
protected virtual async Task <bool> ValidatePaymentMethod(ValidatePaymentMethodParam param)
{
Guard.NotNullOrWhiteSpace(param.CartName, nameof(param.CartName));
Guard.NotNullOrWhiteSpace(param.Scope, nameof(param.Scope));
Guard.NotNullOrWhiteSpace(param.ProviderName, nameof(param.ProviderName));
Guard.NotNull(param.CultureInfo, nameof(param.CultureInfo));
Guard.NotNull(param.CustomerId, nameof(param.CustomerId));
Guard.NotNull(param.PaymentMethodId, nameof(param.PaymentMethodId));
var getPaymentMethodParam = new GetPaymentMethodsParam()
{
CartName = param.CartName,
Scope = param.Scope,
CultureInfo = param.CultureInfo,
CustomerId = param.CustomerId,
IsAuthenticated = param.IsAuthenticated,
ProviderNames = new List <string>()
{
param.ProviderName
}
};
var paymentMethod = await GetAllPaymentMethodsAsync(getPaymentMethodParam).ConfigureAwait(false);
if (paymentMethod == null || paymentMethod.All(p => p.Id != param.PaymentMethodId))
{
throw new Exception($"Payment method for provider name /'{param.ProviderName}/' not found.");
}
return(paymentMethod
.FirstOrDefault(p => p.Id == param.PaymentMethodId)
.IsValid);
}
protected virtual async Task <bool> ValidatePaymentMethod(ValidatePaymentMethodParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (string.IsNullOrWhiteSpace(param.CartName))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.CartName)), nameof(param));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param));
}
if (string.IsNullOrWhiteSpace(param.ProviderName))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.ProviderName)), nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.CustomerId == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CustomerId)), nameof(param));
}
if (param.PaymentMethodId == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.PaymentMethodId)), nameof(param));
}
var getPaymentMethodParam = new GetPaymentMethodsParam()
{
CartName = param.CartName,
Scope = param.Scope,
CultureInfo = param.CultureInfo,
CustomerId = param.CustomerId,
IsAuthenticated = param.IsAuthenticated,
ProviderNames = new List <string>()
{
param.ProviderName
}
};
var paymentMethods = await GetAllPaymentMethodsAsync(getPaymentMethodParam).ConfigureAwait(false);
var paymentMethod = paymentMethods?.Find(x => x.Id == param.PaymentMethodId);
return(paymentMethod?.IsValid ?? throw new Exception($"Payment method for provider name /'{param.ProviderName}/' not found."));;
}
/// <summary>
/// Get the Active Payment methods available for a cart.
/// </summary>
/// <param name="param">GetPaymentMethodsParam</param>
/// <returns>A List of PaymentMethodViewModel</returns>
public virtual async Task <CheckoutPaymentViewModel> GetPaymentMethodsAsync(GetPaymentMethodsParam param)
{
if (param == null)
{
throw new ArgumentNullException("param");
}
if (string.IsNullOrWhiteSpace(param.CartName))
{
throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage("CartName"), "param");
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage("Scope"), "param");
}
if (param.ProviderNames == null)
{
throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage("ProviderName"), "param");
}
var paymentMethods = await GetAllPaymentMethodsAsync(param).ConfigureAwait(false);
var cart = await CartRepository.GetCartAsync(new GetCartParam
{
CartName = param.CartName,
CustomerId = param.CustomerId,
CultureInfo = param.CultureInfo,
Scope = param.Scope
});
var hasRecurring = false;
if (RecurringOrdersSettings.Enabled)
{
hasRecurring = RecurringOrderCartHelper.IsCartContainsRecurringOrderItems(cart);
}
if (hasRecurring)
{
var supported = CartConfiguration.SupportedRecurringOrderPaymentMethodTypes;
paymentMethods = paymentMethods.Where(p => supported.Where(s => s.ToString() == p.PaymentType).Count() > 0).ToList();
}
var vm = await MapCheckoutPaymentViewModel(cart, paymentMethods, param.CultureInfo, param.IsAuthenticated);
return(vm);
}
protected virtual async Task <List <IPaymentMethodViewModel> > GetAllPaymentMethodsAsync(GetPaymentMethodsParam param)
{
var paymentMethods = await PaymentRepository.GetPaymentMethodsAsync(param).ConfigureAwait(false);
if (paymentMethods == null)
{
return(null);
}
var vm = await MapPaymentMethodsViewModel(paymentMethods, param.CultureInfo, param.CustomerId, param.Scope);
return(vm);
}
/// <summary>
/// Obtains the available payment methods for a given provider.
/// </summary>
/// <param name="param">Parameters used to make the request.</param>
/// <param name="providerName">Provider to use in the request.</param>
/// <returns></returns>
protected virtual Task <List <PaymentMethod> > GetPaymentMethodForProviderAsync(GetPaymentMethodsParam param, string providerName)
{
var cacheKey = BuildPaymentMethodCacheKey(param.Scope, param.CartName, param.CustomerId, providerName);
var request = new FindCartPaymentMethodsRequest
{
CartName = param.CartName,
ScopeId = param.Scope,
PaymentProviderName = providerName,
CustomerId = param.CustomerId
};
return(CacheProvider.GetOrAddAsync(cacheKey, () => OvertureClient.SendAsync(request)));
}
/// <summary>
/// Get the Active Payment methods available for a cart.
/// </summary>
/// <param name="param">GetPaymentMethodsParam</param>
/// <returns>A List of PaymentMethodViewModel</returns>
public virtual async Task <SingleCheckoutPaymentViewModel> GetSingleCheckoutPaymentAsync(GetPaymentMethodsParam param)
{
var providers = await GetPaymentProvidersAsync(new GetPaymentProvidersParam
{
Scope = param.Scope,
CultureInfo = param.CultureInfo
}).ConfigureAwait(false);
param.ProviderNames = providers.Select(p => p.ProviderName).ToList();
var results = await GetPaymentMethodsAsync(param);
if (results.ActivePaymentViewModel == null)
{
results.ActivePaymentViewModel = new ActivePaymentViewModel()
{
Id = results.PaymentId ?? default
};
}
return(new SingleCheckoutPaymentViewModel()
{
PaymentMethods = results.PaymentMethods,
PaymentProviders = providers.ToList(),
ActivePaymentViewModel = results.ActivePaymentViewModel
});
}
