public virtual async Task <IHttpActionResult> GetRecurringOrderTemplatesAddressesAsync([FromBody] GetRecurringTemplateAddressRequest request)
{
var recurringOrderScheduleUrl = RecurringScheduleUrlProvider.GetRecurringScheduleDetailsUrl(new GetRecurringScheduleDetailsUrlParam
{
CultureInfo = ComposerContext.CultureInfo,
RecurringScheduleId = request.Id
});
var addAddressUrl = MyAccountUrlProvider.GetAddAddressUrl(new BaseUrlParameter {
CultureInfo = ComposerContext.CultureInfo, ReturnUrl = recurringOrderScheduleUrl
});
var editAddressBaseUrl = MyAccountUrlProvider.GetUpdateAddressBaseUrl(new BaseUrlParameter {
CultureInfo = ComposerContext.CultureInfo, ReturnUrl = recurringOrderScheduleUrl
});
var viewModel = await CustomerAddressViewService.GetAddressListViewModelAsync(new GetAddressListViewModelParam
{
CustomerId = ComposerContext.CustomerId,
CultureInfo = ComposerContext.CultureInfo,
Scope = ComposerContext.Scope,
AddAddressUrl = addAddressUrl,
EditAddressBaseUrl = editAddressBaseUrl,
CountryCode = ComposerContext.CountryCode
});
return(Ok(viewModel));
}
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));
}
protected virtual void FillRecurringScheduleUrl(IRecurringOrderCartViewModel roCartVm, CultureInfo cultureInfo)
{
var url = RecurringScheduleUrlProvider.GetRecurringScheduleUrl(new GetRecurringScheduleUrlParam
{
CultureInfo = cultureInfo
});
roCartVm.RecurringScheduleUrl = url;
}
public virtual async Task <RecurringOrderTemplateViewModel> CreateRecurringOrderTemplateDetailsViewModel(CreateRecurringOrderTemplateDetailsViewModelParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.ProductImageInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ProductImageInfo)), nameof(param));
}
if (param.ProductImageInfo.ImageUrls == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ProductImageInfo.ImageUrls)), nameof(param));
}
if (param.ScopeId == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ScopeId)), nameof(param));
}
if (param.RecurringOrderLineItem == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.RecurringOrderLineItem)), nameof(param));
}
var vm = new RecurringOrderTemplateViewModel();
var imgDictionary = LineItemHelper.BuildImageDictionaryFor(param.ProductImageInfo.ImageUrls);
var recurringScheduleUrl = RecurringScheduleUrlProvider.GetRecurringScheduleUrl(new GetRecurringScheduleUrlParam
{
CultureInfo = param.CultureInfo
});
var lineItemViewModel = await MapToTemplateLineItemViewModel(new MapToTemplateLineItemViewModelParam
{
RecurringOrderlineItem = param.RecurringOrderLineItem,
CultureInfo = param.CultureInfo,
ImageDictionnary = imgDictionary,
BaseUrl = param.BaseUrl,
RecurringScheduleUrl = recurringScheduleUrl
}).ConfigureAwait(false);
if (lineItemViewModel != null)
{
lineItemViewModel.ShippingAddressId = param.RecurringOrderLineItem.ShippingAddressId;
vm.RecurringOrderTemplateLineItemViewModels.Add(lineItemViewModel);
}
return(vm);
}
protected virtual string FindUrl(ListOfRecurringOrderLineItems recurringOrderLineItems, LineItemDetailViewModel lineItem, CultureInfo culture)
{
//TODO: Change if a customer can have more than one template of the same product/variant
var recurringLineItem = recurringOrderLineItems.RecurringOrderLineItems.SingleOrDefault(r =>
string.Equals(r.ProductId, lineItem.ProductId, StringComparison.OrdinalIgnoreCase) &&
string.Equals(r.VariantId, lineItem.VariantId, StringComparison.OrdinalIgnoreCase));
if (recurringLineItem == null)
{
return(string.Empty);
}
var url = RecurringScheduleUrlProvider.GetRecurringScheduleDetailsUrl(new GetRecurringScheduleDetailsUrlParam()
{
CultureInfo = culture,
RecurringScheduleId = recurringLineItem.RecurringOrderLineItemId.ToString()
});
return(url);
}
public virtual async Task <RecurringOrderTemplateLineItemViewModel> MapToTemplateLineItemViewModel(MapToTemplateLineItemViewModelParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.RecurringOrderlineItem == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.RecurringOrderlineItem)), nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.BaseUrl == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.BaseUrl)), nameof(param));
}
if (param.RecurringScheduleUrl == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.RecurringScheduleUrl)), nameof(param));
}
var recrurringLineItem = param.RecurringOrderlineItem;
var vm = ViewModelMapper.MapTo <RecurringOrderTemplateLineItemViewModel>(recrurringLineItem, param.CultureInfo);
if (vm.IsValid == null)
{
vm.IsValid = true;
}
if (param.ImageDictionnary.TryGetValue(Tuple.Create(recrurringLineItem.ProductId, recrurringLineItem.VariantId), out ProductMainImage mainImage))
{
vm.ImageUrl = mainImage.ImageUrl;
vm.FallbackImageUrl = mainImage.FallbackImageUrl;
}
var getProductRequest = new Overture.ServiceModel.Requests.Products.GetProductRequest
{
ProductId = recrurringLineItem.ProductId,
ScopeId = recrurringLineItem.ScopeId,
CultureName = param.CultureInfo.Name,
IncludePriceLists = true,
IncludeRelationships = false,
IncludeVariants = true
};
var getProductResponse = await OvertureClient.SendAsync(getProductRequest).ConfigureAwait(false);
if (getProductResponse == null || (getProductResponse != null && recrurringLineItem.VariantId != string.Empty &&
recrurringLineItem.VariantId != null &&
getProductResponse.Variants.SingleOrDefault(v => v.Id == recrurringLineItem.VariantId) == null))
{
var deleteRecurringLineItem = new DeleteRecurringOrderLineItemsRequest
{
CustomerId = recrurringLineItem.CustomerId,
RecurringOrderLineItemIds = new List <Guid> {
recrurringLineItem.RecurringOrderLineItemId
},
ScopeId = recrurringLineItem.ScopeId
};
await OvertureClient.SendAsync(deleteRecurringLineItem);
return(await Task.FromResult <RecurringOrderTemplateLineItemViewModel>(null));
}
var variant = getProductResponse.Variants.SingleOrDefault(v => v.Id == recrurringLineItem.VariantId);
vm.FormattedNextOccurence = vm.NextOccurence == DateTime.MinValue
? string.Empty
: string.Format(param.CultureInfo, "{0:D}", vm.NextOccurence);
vm.NextOccurenceValue = vm.NextOccurence == DateTime.MinValue
? string.Empty
: vm.NextOccurence.ToString("yyyy/MM/dd", CultureInfo.InvariantCulture);
vm.Id = recrurringLineItem.RecurringOrderLineItemId;
vm.ProductSummary = new RecurringProductSummaryViewModel
{
DisplayName = ProductHelper.GetProductOrVariantDisplayName(getProductResponse, variant, param.CultureInfo)
};
var productsPricesVm = await ProductPriceViewService.CalculatePricesAsync(new GetProductsPriceParam
{
CultureInfo = param.CultureInfo,
Scope = recrurringLineItem.ScopeId,
ProductIds = new List <string>()
{
recrurringLineItem.ProductId
}
});
var productPriceVm = productsPricesVm.ProductPrices.SingleOrDefault(p => p.ProductId == recrurringLineItem.ProductId);
if (productPriceVm != null)
{
var variantPriceVm = productPriceVm.VariantPrices.SingleOrDefault(v => v.VariantId == recrurringLineItem.VariantId);
if (variantPriceVm != null)
{
vm.DefaultListPrice = variantPriceVm.DefaultListPrice;
vm.ListPrice = variantPriceVm.ListPrice;
}
else
{
vm.DefaultListPrice = productPriceVm.DefaultListPrice;
vm.ListPrice = productPriceVm.ListPrice;
}
}
vm.IsOnSale = string.CompareOrdinal(vm.DefaultListPrice, vm.ListPrice) != 0;
var conv = decimal.TryParse(vm.ListPrice, NumberStyles.Currency, param.CultureInfo.NumberFormat, out decimal price);
if (conv)
{
vm.TotalWithoutDiscount = LocalizationProvider.FormatPrice((decimal)vm.Quantity * price, param.CultureInfo);
vm.Total = LocalizationProvider.FormatPrice((decimal)vm.Quantity * price, param.CultureInfo);
}
//Adding brand display name
var brandLookup = await OvertureClient.SendAsync(new GetProductLookupRequest { LookupName = "Brand" });
var brandId = getProductResponse.Brand;
if (brandId != null)
{
string brandValue = Convert.ToString(brandId);
vm.ProductSummary.Brand = brandLookup?.GetDisplayName(brandValue, param.CultureInfo.Name) ?? brandId;
}
var list = await ProductHelper.GetKeyVariantAttributes(getProductResponse, variant, param.CultureInfo, OvertureClient);
if (list != null && list.Count > 0)
{
vm.KeyVariantAttributesList = list.ToList();
}
vm.ShippingMethodName = recrurringLineItem.FulfillmentMethodName;
vm.ProductUrl = ProductUrlProvider.GetProductUrl(new GetProductUrlParam
{
CultureInfo = param.CultureInfo,
VariantId = recrurringLineItem.VariantId,
ProductId = recrurringLineItem.ProductId,
ProductName = vm.ProductSummary.DisplayName,
SKU = recrurringLineItem.Sku
});
var recurringScheduleEditUrl = RecurringScheduleUrlProvider.GetRecurringScheduleDetailsUrl(new GetRecurringScheduleDetailsUrlParam
{
CultureInfo = param.CultureInfo,
RecurringScheduleId = vm.Id.ToString()
});
vm.EditUrl = recurringScheduleEditUrl;
vm.ScheduleUrl = param.RecurringScheduleUrl;
var program = await RecurringOrderRepository.GetRecurringOrderProgram(recrurringLineItem.ScopeId, recrurringLineItem.RecurringOrderProgramName);
var programViewModel = RecurringOrderProgramViewModelFactory.CreateRecurringOrderProgramViewModel(program, param.CultureInfo);
vm.RecurringOrderProgramFrequencies = programViewModel?.Frequencies;
return(vm);
}
public virtual async Task <List <RecurringOrderTemplateViewModel> > CreateTemplateGroupedShippingAddress(CreateTemplateGroupedShippingAddressParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.ListOfRecurringOrderLineItems == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ListOfRecurringOrderLineItems)), nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.ProductImageInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ProductImageInfo)), nameof(param));
}
if (param.ProductImageInfo.ImageUrls == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ProductImageInfo.ImageUrls)), nameof(param));
}
if (param.ScopeId == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ScopeId)), nameof(param));
}
var groups = param.ListOfRecurringOrderLineItems.RecurringOrderLineItems.GroupBy(grp => grp.ShippingAddressId);
var imgDictionary = LineItemHelper.BuildImageDictionaryFor(param.ProductImageInfo.ImageUrls);
var itemList = new List <RecurringOrderTemplateViewModel>();
var recurringScheduleUrl = RecurringScheduleUrlProvider.GetRecurringScheduleUrl(new GetRecurringScheduleUrlParam
{
CultureInfo = param.CultureInfo,
});
foreach (var group in groups)
{
var templateViewModel = new RecurringOrderTemplateViewModel
{
ShippingAddress = await MapShippingAddress(group.Key, param.CultureInfo).ConfigureAwait(false)
};
var tasks = group.Select(g => MapToTemplateLineItemViewModel(new MapToTemplateLineItemViewModelParam
{
RecurringOrderlineItem = g,
CultureInfo = param.CultureInfo,
ImageDictionnary = imgDictionary,
BaseUrl = param.BaseUrl,
RecurringScheduleUrl = recurringScheduleUrl
}));
var templateLineItems = await Task.WhenAll(tasks);
//Filter null to not have an error when rendering the page
templateViewModel.RecurringOrderTemplateLineItemViewModels.AddRange(templateLineItems.Where(t => t != null).ToList());
itemList.Add(templateViewModel);
}
return(itemList);
}
public virtual MenuViewModel CreateMenu(string currentUrl)
{
var urlParam = new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
};
bool recurringOrderConfigEnabled = RecurringOrdersSettings.Enabled;
var myAccountUrl = MyAccountUrlProvider.GetMyAccountUrl(urlParam);
var addressListUrl = MyAccountUrlProvider.GetAddressListUrl(urlParam);
var myOrderHistoryUrl = OrderUrlProvider.GetOrderHistoryUrl(new GetOrderUrlParameter {
CultureInfo = ComposerContext.CultureInfo
});
var myWishListUrl = WishListUrlProvider.GetWishListUrl(new GetWishListUrlParam {
CultureInfo = ComposerContext.CultureInfo
});
var myRecurringScheduleUrl = RecurringScheduleUrlProvider.GetRecurringScheduleUrl(new GetRecurringScheduleUrlParam {
CultureInfo = ComposerContext.CultureInfo
});
var currentPageId = new Guid(currentUrl);
var menu = new MenuViewModel {
MenuItems = new List <MenuItemViewModel>()
};
var pageConfiguration = SiteConfiguration.GetPagesConfiguration(ComposerContext.CultureInfo, WebsiteContext.WebsiteId);
var myAccountPage = PageService.GetPage(pageConfiguration.MyAccountPageId, ComposerContext.CultureInfo);
var myAddressPage = PageService.GetPage(pageConfiguration.AddressListPageId, ComposerContext.CultureInfo);
var myOrderHistoryPage = PageService.GetPage(pageConfiguration.OrderHistoryPageId, ComposerContext.CultureInfo);
var myWishListage = PageService.GetPage(pageConfiguration.MyWishListPageId, ComposerContext.CultureInfo);
var myRecurringSchedulePage = PageService.GetPage(RecurringOrdersSettings.RecurringSchedulePageId, ComposerContext.CultureInfo);
var myAccountMenuItem = new MenuItemViewModel
{
Name = myAccountPage.MenuTitle,
Url = myAccountUrl,
IsActive = currentPageId == pageConfiguration.MyAccountPageId ||
currentPageId == pageConfiguration.ChangePasswordPageId
};
var myAdressesMenuItem = new MenuItemViewModel
{
Name = myAddressPage.MenuTitle,
Url = addressListUrl,
IsActive = currentPageId == pageConfiguration.AddressListPageId ||
currentPageId == pageConfiguration.AddAddressPageId ||
currentPageId == pageConfiguration.UpdateAddressPageId
};
var myWishListMenuItem = new MenuItemViewModel
{
Name = myWishListage.MenuTitle,
Url = myWishListUrl,
IsActive = currentPageId == pageConfiguration.MyWishListPageId
};
var myOrderHistoryMenuItem = new MenuItemViewModel
{
Name = myOrderHistoryPage.MenuTitle,
Url = myOrderHistoryUrl,
IsActive = currentPageId == pageConfiguration.OrderHistoryPageId ||
currentPageId == pageConfiguration.OrderDetailsPageId ||
currentPageId == RecurringOrdersSettings.RecurringCartDetailsPageId
};
var myRecurringScheduleMenuItem = new MenuItemViewModel
{
Name = myRecurringSchedulePage.MenuTitle,
Url = myRecurringScheduleUrl,
IsActive = currentPageId == RecurringOrdersSettings.RecurringSchedulePageId || currentPageId == RecurringOrdersSettings.RecurringScheduleDetailsPageId
};
menu.MenuItems.AddRange(new List <MenuItemViewModel> {
myAccountMenuItem, myWishListMenuItem, myAdressesMenuItem, myOrderHistoryMenuItem
});
if (recurringOrderConfigEnabled)
{
menu.MenuItems.Add(myRecurringScheduleMenuItem);
}
return(menu);
}
