protected virtual string GetRecurringOrderFrequencyDisplayName(RecurringOrderProgram program, LineItem lineItem, CultureInfo cultureInfo)
{
if (RecurringOrderCartHelper.IsRecurringOrderLineItemValid(lineItem))
{
if (program != null)
{
var frequency = program.Frequencies.FirstOrDefault(f => string.Equals(f.RecurringOrderFrequencyName, lineItem.RecurringOrderFrequencyName, StringComparison.OrdinalIgnoreCase));
if (frequency != null)
{
var localization = frequency.Localizations.FirstOrDefault(l => string.Equals(l.CultureIso, cultureInfo.Name, StringComparison.OrdinalIgnoreCase));
if (localization != null)
{
return(localization.DisplayName);
}
else
{
return(frequency.RecurringOrderFrequencyName);
}
}
}
}
return(string.Empty);
}
protected virtual void MapRecurringOrderLineitemFrequencyName(CartViewModel recurringOrderCartViewModel, CultureInfo culture, List <RecurringOrderProgram> recurringOrderPrograms)
{
if (recurringOrderCartViewModel.LineItemDetailViewModels == null)
{
return;
}
foreach (var lineitem in recurringOrderCartViewModel.LineItemDetailViewModels)
{
if (RecurringOrderCartHelper.IsRecurringOrderLineItemValid(lineitem))
{
var program = recurringOrderPrograms.FirstOrDefault(p => string.Equals(p.RecurringOrderProgramName, lineitem.RecurringOrderProgramName, StringComparison.OrdinalIgnoreCase));
if (program != null)
{
var frequency = program.Frequencies.FirstOrDefault(f => string.Equals(f.RecurringOrderFrequencyName, lineitem.RecurringOrderFrequencyName, StringComparison.OrdinalIgnoreCase));
if (frequency != null)
{
var localization = frequency.Localizations.FirstOrDefault(l => string.Equals(l.CultureIso, culture.Name, StringComparison.OrdinalIgnoreCase));
if (localization != null)
{
lineitem.RecurringOrderFrequencyDisplayName = localization.DisplayName;
}
else
{
lineitem.RecurringOrderFrequencyDisplayName = frequency.RecurringOrderFrequencyName;
}
}
}
}
}
}
/// <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);
}
/// <summary>
/// Gets the ActivePaymentViewModel based on parameters.
/// </summary>
/// <param name="param">Parameter used to retrieve the ViewModel.</param>
/// <returns></returns>
protected virtual ActivePaymentViewModel GetActivePaymentViewModel(GetActivePaymentViewModelParam param)
{
if (param.Cart == null)
{
return(null);
}
var payment = GetActivePayment(param.Cart);
var vm = ViewModelMapper.MapTo <ActivePaymentViewModel>(payment, param.CultureInfo);
vm.ShouldCapturePayment = param.PaymentProvider.ShouldCapturePayment(payment);
if (vm.ShouldCapturePayment)
{
vm.CapturePaymentUrl = param.PaymentProvider.GetCapturePaymentUrl(payment, param.CultureInfo);
}
if (payment.PaymentMethod != null)
{
vm.PaymentMethodType = payment.PaymentMethod.Type.ToString();
}
vm.ProviderName = param.PaymentProvider.ProviderName;
vm.ProviderType = param.PaymentProvider.ProviderType;
// TODO: Update when multiple payment provider available please
// Quick hack, since we only support saving the payment method only
// for Moneris currently (when the user is authenticated)
vm.CanSavePaymentMethod = vm.ProviderType == MonerisCanadaPaymentProvider.MonerisProviderTypeName && param.IsAuthenticated;
// Recurring orders must have a saved credit card to work.
vm.MustSavePaymentMethod = vm.CanSavePaymentMethod && RecurringOrdersSettings.Enabled && RecurringOrderCartHelper.IsCartContainsRecurringOrderItems(param.Cart);
param.PaymentProvider.AugmentViewModel(vm, payment);
return(vm);
}
public virtual async Task <RecurringOrderCartsRescheduleResultViewModel> UpdateRecurringOrderCartNextOccurenceAsync(UpdateRecurringOrderCartNextOccurenceParam param)
{
if (!RecurringOrdersSettings.Enabled)
{
return(new RecurringOrderCartsRescheduleResultViewModel());
}
if (param == null)
{
throw new ArgumentNullException(nameof(param), ArgumentNullMessageFormatter.FormatErrorMessage(nameof(param)));
}
//get customer cart
var cart = await CartRepository.GetCartAsync(new GetCartParam {
CartName = param.CartName,
CultureInfo = param.CultureInfo,
CustomerId = param.CustomerId,
Scope = param.Scope,
ExecuteWorkflow = false
}).ConfigureAwait(false);
var originalCartName = param.CartName;
//get customer recurring lineitems
var listOfRecurringLineItems = await RecurringOrdersRepository.GetRecurringOrderTemplates(param.Scope, param.CustomerId);
if (listOfRecurringLineItems == null)
{
throw new InvalidOperationException($"Recurring lineItems for customer {param.CustomerId} not found");
}
var recurringLineItem = new RecurringOrderLineItem();
var continueShipment = true;
//We need to conserve the same time
foreach (var shipment in cart.Shipments)
{
foreach (var lineitem in shipment.LineItems)
{
if (RecurringOrderCartHelper.IsRecurringOrderLineItemValid(lineitem))
{
var recurringOrderLineitem = listOfRecurringLineItems.RecurringOrderLineItems?.FirstOrDefault(l =>
RecurringOrderTemplateHelper.IsLineItemAndRecurringTemplateLineItemSameProduct(lineitem, l));
if (recurringOrderLineitem != null)
{
recurringLineItem = recurringOrderLineitem;
continueShipment = false;
break;
}
}
}
if (!continueShipment)
{
break;
}
}
var newDate = param.NextOccurence;
if (Guid.Empty != recurringLineItem.RecurringOrderLineItemId)
{
var nextOccurenceWithTime = recurringLineItem.NextOccurence;
newDate = new DateTime(param.NextOccurence.Year, param.NextOccurence.Month, param.NextOccurence.Day,
nextOccurenceWithTime.Hour, nextOccurenceWithTime.Minute, nextOccurenceWithTime.Second, DateTimeKind.Utc);
}
var listOfRecurringOrderLineItemsUpdated = await CartRepository.RescheduleRecurringCartAsync(new RescheduleRecurringCartParam()
{
CustomerId = param.CustomerId,
NextOccurence = newDate,
Scope = param.Scope,
CartName = param.CartName
});
var vm = new RecurringOrderCartsRescheduleResultViewModel();
var carts = await CartRepository.GetRecurringCartsAsync(new GetRecurringOrderCartsViewModelParam
{
BaseUrl = param.BaseUrl,
Scope = param.Scope,
CustomerId = param.CustomerId,
CultureInfo = param.CultureInfo
});
vm.RescheduledCartHasMerged = !carts.Any(rc => string.Compare(rc.Name, originalCartName, StringComparison.OrdinalIgnoreCase) == 0);
var cartsVm = await GetRecurringOrderCartListViewModelFromCartsAsync(new GetRecurringOrderCartsViewModelFromCartsParam
{
Carts = carts,
BaseUrl = param.BaseUrl,
CultureInfo = param.CultureInfo
});
vm.RecurringOrderCartsViewModel = cartsVm;
var url = RecurringCartUrlProvider.GetRecurringCartsUrl(new GetRecurringCartsUrlParam
{
CultureInfo = param.CultureInfo
});
vm.RecurringCartsUrl = url;
return(vm);
}
