public virtual ActionResult CheckoutSignInAsGuest()
{
var checkoutUrl = UrlProvider.GetCheckoutPageUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
var registerUrl = MyAccountUrlProvider.GetCreateAccountUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo,
ReturnUrl = checkoutUrl
});
var cart = CartService.GetCartViewModelAsync(new GetCartParam()
{
BaseUrl = RequestUtils.GetBaseUrl(Request).ToString(),
CartName = CartConfiguration.ShoppingCartName,
CultureInfo = ComposerContext.CultureInfo,
CustomerId = ComposerContext.CustomerId,
ExecuteWorkflow = true,
Scope = ComposerContext.Scope
}).Result;
var hasRecurringItems = cart.HasRecurringLineitems;
var checkoutSignInAsGuestViewModel = new CheckoutSignInAsGuestViewModel
{
CheckoutUrlTarget = checkoutUrl,
RegisterUrl = registerUrl,
IsCartContainsRecurringLineitems = hasRecurringItems
};
return(View("CheckoutSignInAsGuest", checkoutSignInAsGuestViewModel));
}
public virtual IHttpActionResult Logout(LogoutRequest logoutRequest)
{
if (logoutRequest == null)
{
throw new ArgumentNullException(nameof(logoutRequest));
}
var response = new LogoutResponse();
if (!logoutRequest.PreserveCustomerInfo)
{
InvalidateCustomerCookie();
}
FormsAuthentication.SignOut();
response.ReturnUrl = logoutRequest.ReturnUrl;
if (string.IsNullOrWhiteSpace(response.ReturnUrl) || !UrlFormatter.IsReturnUrlValid(RequestUtils.GetBaseUrl(Request).ToString(), response.ReturnUrl))
{
response.ReturnUrl = MyAccountUrlProvider.GetLoginUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
}
return(Ok(response));
}
/// <summary>
/// Get the view Model to display a Reset Password Form and Form result
/// </summary>
/// <param name="param">Builder params <see cref="GetResetPasswordByTicketViewModelParam"/></param>
/// <returns>
/// The view model to display the Reset Password Form
/// </returns>
public virtual async Task <ResetPasswordViewModel> GetCustomerByTicketResetPasswordViewModelAsync(GetResetPasswordByTicketViewModelParam param)
{
if (param == null)
{
throw new ArgumentNullException("param");
}
if (param.CultureInfo == null)
{
throw new ArgumentException("param.CultureInfo");
}
var forgotPasswordUrl = MyAccountUrlProvider.GetForgotPasswordUrl(new BaseUrlParameter {
CultureInfo = param.CultureInfo
});
var customer = await GetCustomerByTicketAsync(new GetCustomerByTicketParam
{
Ticket = param.Ticket
}).ConfigureAwait(false);
return(GetResetPasswordViewModel(new GetResetPasswordViewModelParam
{
Customer = customer,
CultureInfo = param.CultureInfo,
ForgotPasswordUrl = forgotPasswordUrl
}));
}
public virtual async Task <IHttpActionResult> ResetPasswordAsync(ResetPasswordRequest resetPasswordRequest)
{
if (resetPasswordRequest == null)
{
return(BadRequest("No body found in the request"));
}
var returnUrl = resetPasswordRequest.ReturnUrl;
if (string.IsNullOrWhiteSpace(returnUrl) || !UrlFormatter.IsReturnUrlValid(RequestUtils.GetBaseUrl(Request).ToString(), returnUrl))
{
returnUrl = MyAccountUrlProvider.GetLoginUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
}
var ticket = HttpUtility.UrlDecode(resetPasswordRequest.Ticket);
var resetPasswordViewModel = await MembershipViewService.ResetPasswordAsync(new ResetPasswordParam
{
Ticket = ticket,
NewPassword = resetPasswordRequest.NewPassword,
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
ReturnUrl = returnUrl
});
return(Ok(resetPasswordViewModel));
}
/// <summary>
/// Get the view Model to display the Sign In Header
/// </summary>
/// <returns>
/// The view model to display the Sign In Header
/// </returns>
public virtual async Task <SignInHeaderViewModel> GetSignInHeaderModel(GetSignInHeaderParam param)
{
var myAccountUrl = MyAccountUrlProvider.GetMyAccountUrl(new BaseUrlParameter
{
CultureInfo = param.CultureInfo
});
var loginUrl = MyAccountUrlProvider.GetLoginUrl(new BaseUrlParameter
{
CultureInfo = param.CultureInfo
});
var customer = await CustomerRepository.GetCustomerByIdAsync(new GetCustomerByIdParam
{
CultureInfo = param.CultureInfo,
CustomerId = param.CustomerId,
Scope = param.Scope
}).ConfigureAwait(false);
var viewModel = ViewModelMapper.MapTo <SignInHeaderViewModel>(customer, param.CultureInfo) ?? new SignInHeaderViewModel();
viewModel.IsLoggedIn = param.IsAuthenticated;
viewModel.EncryptedCustomerId = param.EncryptedCustomerId;
viewModel.Url = viewModel.IsLoggedIn ? myAccountUrl : loginUrl;
return(viewModel);
}
public virtual async Task <IHttpActionResult> GetRecurringCartAddressAsync([FromBody] GetRecurringCartAddressRequest request)
{
if (request == null)
{
return(BadRequest("Missing Request Body"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var cartsUrl = RecurringCartUrlProvider.GetRecurringCartDetailsUrl(new GetRecurringCartDetailsUrlParam {
CultureInfo = ComposerContext.CultureInfo,
RecurringCartName = request.CartName
});
var addAddressUrl = MyAccountUrlProvider.GetAddAddressUrl(new BaseUrlParameter {
CultureInfo = ComposerContext.CultureInfo, ReturnUrl = cartsUrl
});
var editAddressBaseUrl = MyAccountUrlProvider.GetUpdateAddressBaseUrl(new BaseUrlParameter {
CultureInfo = ComposerContext.CultureInfo, ReturnUrl = cartsUrl
});
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));
}
//TODO: Change the method name for GetAdressListAsync or something similar because it confuse people
public virtual async Task <IHttpActionResult> GetShippingAddressAsync()
{
var checkoutAddressStepUrl = CartUrlProvider.GetCheckoutStepUrl(new GetCheckoutStepUrlParam
{
CultureInfo = ComposerContext.CultureInfo,
StepNumber = 1,
});
var urlParam = new BaseUrlParameter {
CultureInfo = ComposerContext.CultureInfo,
ReturnUrl = checkoutAddressStepUrl
};
var addressListUrl = MyAccountUrlProvider.GetAddressListUrl(urlParam);
var addAddressUrl = CartUrlProvider.GetCheckoutAddAddressUrl(urlParam);
var editAddressBaseUrl = CartUrlProvider.GetCheckoutUpdateAddressBaseUrl(urlParam);
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> UpdateAddressAsync(Guid id, EditAddressRequest request)
{
var returnUrl = request.ReturnUrl;
if (string.IsNullOrWhiteSpace(returnUrl) || !UrlFormatter.IsReturnUrlValid(RequestUtils.GetBaseUrl(Request).ToString(), returnUrl))
{
returnUrl = MyAccountUrlProvider.GetAddressListUrl(new BaseUrlParameter {
CultureInfo = ComposerContext.CultureInfo
});
}
var viewModel = await CustomerAddressViewService.UpdateAddressAsync(new EditAddressParam
{
CustomerId = ComposerContext.CustomerId,
CultureInfo = ComposerContext.CultureInfo,
Scope = ComposerContext.Scope,
EditAddress = request,
AddressId = id,
ReturnUrl = returnUrl
});
if (viewModel == null)
{
return(Unauthorized());
}
return(Ok(viewModel));
}
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 ActionResult NewCustomerBlade()
{
var returnUrl = GetReturnUrlToPreserve();
var loginUrl = MyAccountUrlProvider.GetLoginUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo,
ReturnUrl = returnUrl
});
var createAccountUrl = MyAccountUrlProvider.GetCreateAccountUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo,
ReturnUrl = returnUrl
});
var forgotPasswordUrl = MyAccountUrlProvider.GetForgotPasswordUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo,
ReturnUrl = returnUrl
});
var loginViewModel = MembershipViewService.GetLoginViewModel(new GetLoginViewModelParam
{
CultureInfo = ComposerContext.CultureInfo,
CreateAccountUrl = createAccountUrl,
ForgotPasswordUrl = forgotPasswordUrl,
LoginUrl = loginUrl,
ReturnUrl = returnUrl
});
return(View("NewCustomerBlade", loginViewModel));
}
public virtual async Task <IHttpActionResult> UpdateAccountAsync(EditAccountRequest request)
{
var param = new UpdateAccountParam
{
CustomerId = ComposerContext.CustomerId,
Scope = ComposerContext.Scope,
PreferredLanguage = request.PreferredLanguage,
Email = request.Email,
FirstName = request.FirstName,
LastName = request.LastName,
CultureInfo = ComposerContext.CultureInfo,
};
var urlParam = new BaseUrlParameter {
CultureInfo = param.CultureInfo
};
var addressListUrl = MyAccountUrlProvider.GetAddressListUrl(urlParam);
var changePasswordUrl = MyAccountUrlProvider.GetChangePasswordUrl(urlParam);
var viewModel = await CustomerViewService.UpdateAccountAsync(param);
if (viewModel == null)
{
return(Unauthorized());
}
viewModel.AddressListUrl = addressListUrl;
viewModel.ChangePasswordUrl = changePasswordUrl;
return(Ok(viewModel));
}
public virtual IHttpActionResult Register(RegisterRequest registerRequest)
{
//todo: Captcha for bots or not?!
if (registerRequest == null)
{
return(BadRequest("No body found in the request"));
}
var returnUrl = registerRequest.ReturnUrl;
if (string.IsNullOrWhiteSpace(returnUrl) || !UrlFormatter.IsReturnUrlValid(RequestUtils.GetBaseUrl(Request).ToString(), returnUrl))
{
returnUrl = MyAccountUrlProvider.GetMyAccountUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
}
var registerParam = new CreateUserParam
{
Username = registerRequest.Username,
Password = registerRequest.Password,
Email = registerRequest.Email,
FirstName = registerRequest.FirstName,
LastName = registerRequest.LastName,
PhoneNumber = registerRequest.PhoneNumber,
PasswordQuestion = registerRequest.PasswordQuestion,
PasswordAnswer = registerRequest.PasswordAnswer,
ReturnUrl = returnUrl,
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
GuestCustomerId = ComposerContext.CustomerId
};
var createAccountViewModel = MembershipViewService.RegisterAsync(registerParam).Result;
if (!createAccountViewModel.IsSuccess)
{
return(Ok(createAccountViewModel));
}
var loginParam = new LoginParam
{
CultureInfo = ComposerContext.CultureInfo,
Scope = ComposerContext.Scope,
GuestCustomerId = ComposerContext.CustomerId,
Username = registerRequest.Email,
Password = registerRequest.Password
};
var loginViewModel = MembershipViewService.LoginAsync(loginParam).Result;
ComposerContext.IsGuest = false;
ComposerContext.CustomerId = createAccountViewModel.CustomerId;
FormsAuthentication.SetAuthCookie(createAccountViewModel.Username, true, WebsiteContext.WebsiteId.ToString());
return(Ok(createAccountViewModel));
}
/// <summary>
/// Create a customer account.
/// </summary>
/// <param name="createUserParam">Service call params <see cref="CreateUserParam"/></param>
/// <returns>
/// The Created in Customer and a status representing a possible cause of errors
/// </returns>
public virtual async Task <CreateAccountViewModel> RegisterAsync(CreateUserParam createUserParam)
{
if (createUserParam == null)
{
throw new ArgumentNullException("createUserParam");
}
if (createUserParam.CultureInfo == null)
{
throw new ArgumentException("createUserParam.CultureInfo");
}
if (string.IsNullOrWhiteSpace(createUserParam.Password))
{
throw new ArgumentException("createUserParam.Password");
}
if (string.IsNullOrWhiteSpace(createUserParam.FirstName))
{
throw new ArgumentException("createUserParam.FirstName");
}
if (string.IsNullOrWhiteSpace(createUserParam.LastName))
{
throw new ArgumentException("createUserParam.LastName");
}
if (string.IsNullOrWhiteSpace(createUserParam.Email))
{
throw new ArgumentException("createUserParam.Email");
}
if (string.IsNullOrWhiteSpace(createUserParam.Scope))
{
throw new ArgumentException("createUserParam.Scope");
}
var termsAndConditionsUrl = MyAccountUrlProvider.GetTermsAndConditionsUrl(new BaseUrlParameter {
CultureInfo = createUserParam.CultureInfo
});
var customer = await CustomerRepository.CreateUserAsync(new CreateUserParam
{
CustomerId = Guid.Empty,
Email = createUserParam.Email,
FirstName = createUserParam.FirstName,
LastName = createUserParam.LastName,
Username = createUserParam.Username,
Password = createUserParam.Password,
PasswordQuestion = createUserParam.PasswordQuestion,
PasswordAnswer = createUserParam.PasswordAnswer,
CultureInfo = createUserParam.CultureInfo,
Scope = createUserParam.Scope
}).ConfigureAwait(false);
return(GetCreateAccountViewModel(new GetCreateAccountViewModelParam
{
ReturnUrl = createUserParam.ReturnUrl,
Status = customer.AccountStatus == AccountStatus.RequiresApproval ? MyAccountStatus.RequiresApproval : MyAccountStatus.Success,
CultureInfo = createUserParam.CultureInfo,
Customer = customer,
TermsAndConditionsUrl = termsAndConditionsUrl
}));
}
public virtual IHttpActionResult SignIn(LoginViewModel loginRequest)
{
if (loginRequest == null)
{
return(BadRequest("Request body cannot be null"));
}
var returnUrl = loginRequest.ReturnUrl;
if (string.IsNullOrWhiteSpace(returnUrl) || !UrlFormatter.IsReturnUrlValid(RequestUtils.GetBaseUrl(Request).ToString(), returnUrl))
{
returnUrl = MyAccountUrlProvider.GetMyAccountUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
}
var loginParam = new LoginParam
{
Password = loginRequest.Password,
Username = loginRequest.Username,
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
ReturnUrl = returnUrl,
GuestCustomerId = ComposerContext.CustomerId,
};
var loginViewModel = MembershipViewService.LoginAsync(loginParam).Result;
if (!loginViewModel.IsSuccess)
{
return(Ok(loginViewModel));
}
ComposerContext.CustomerId = loginViewModel.CustomerId;
ComposerContext.IsGuest = false;
if (loginRequest.IsRememberMe)
{
FormsAuthentication.SetAuthCookie(
loginViewModel.Username,
SiteConfiguration.CookieAccesserSettings.TimeoutInMinutes,
loginRequest.IsRememberMe,
WebsiteContext.WebsiteId.ToString(),
SiteConfiguration.CookieAccesserSettings.RequireSsl);
}
else
{
FormsAuthentication.SetAuthCookie(loginViewModel.Username, true, WebsiteContext.WebsiteId.ToString());
}
return(Ok(loginViewModel));
}
public virtual ActionResult CheckoutSignInAsCustomer()
{
var forgotPasswordUrl = MyAccountUrlProvider.GetForgotPasswordUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
var vm = new CheckoutSignInAsReturningViewModel
{
ForgotPasswordUrl = forgotPasswordUrl
};
return(View("ReturningCustomerBlade", vm));
}
/// <summary>
/// Sets the new password for the user idenfied by the secure Ticket.
/// </summary>
/// <param name="resetPasswordParam">Service call params <see cref="ResetPasswordParam"/></param>
/// <returns>
/// The updated Customer and a status representing a possible cause of errors
/// </returns>
public virtual async Task <ResetPasswordViewModel> ResetPasswordAsync(ResetPasswordParam resetPasswordParam)
{
if (resetPasswordParam == null)
{
throw new ArgumentNullException("resetPasswordParam");
}
if (string.IsNullOrWhiteSpace(resetPasswordParam.Ticket))
{
throw new ArgumentException("resetPasswordParam.Ticket");
}
if (resetPasswordParam.CultureInfo == null)
{
throw new ArgumentException("resetPasswordParam.CultureInfo");
}
if (string.IsNullOrWhiteSpace(resetPasswordParam.Scope))
{
throw new ArgumentException("resetPasswordParam.Scope");
}
if (string.IsNullOrWhiteSpace(resetPasswordParam.NewPassword))
{
throw new ArgumentException("resetPasswordParam.NewPassword");
}
if (string.IsNullOrWhiteSpace(resetPasswordParam.PasswordAnswer) && MembershipProvider.RequiresQuestionAndAnswer)
{
throw new ArgumentException("resetPasswordParam.PasswordAnswer");
}
var forgotPasswordUrl = MyAccountUrlProvider.GetForgotPasswordUrl(
new BaseUrlParameter {
CultureInfo = resetPasswordParam.CultureInfo
});
var customer = await CustomerRepository.GetCustomerByTicketAsync(resetPasswordParam.Ticket).ConfigureAwait(false);
await CustomerRepository.ResetPasswordAsync(
customer.Username,
resetPasswordParam.Scope,
resetPasswordParam.NewPassword,
resetPasswordParam.PasswordAnswer).ConfigureAwait(false);
return(GetResetPasswordViewModel(new GetResetPasswordViewModelParam
{
ReturnUrl = resetPasswordParam.ReturnUrl,
Status = MyAccountStatus.Success,
Customer = customer,
CultureInfo = resetPasswordParam.CultureInfo,
ForgotPasswordUrl = forgotPasswordUrl
}));
}
public virtual ActionResult CreateAccountBlade()
{
var termsAndConditionsUrl = MyAccountUrlProvider.GetTermsAndConditionsUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
var createAccountViewModel =
MembershipViewService.GetCreateAccountViewModel(new GetCreateAccountViewModelParam
{
ReturnUrl = GetReturnUrlToPreserve(),
TermsAndConditionsUrl = termsAndConditionsUrl
});
return(View("CreateAccountBlade", createAccountViewModel));
}
public virtual ActionResult AddressList()
{
var urlParam = new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
};
var addAddressUrl = MyAccountUrlProvider.GetAddAddressUrl(urlParam);
var editAddressBaseUrl = MyAccountUrlProvider.GetUpdateAddressBaseUrl(urlParam);
var viewModel = CustomerAddressViewService.GetAddressListViewModelAsync(new GetAddressListViewModelParam
{
CustomerId = ComposerContext.CustomerId,
CultureInfo = ComposerContext.CultureInfo,
Scope = ComposerContext.Scope,
AddAddressUrl = addAddressUrl,
EditAddressBaseUrl = editAddressBaseUrl,
CountryCode = ComposerContext.CountryCode
}).Result;
return(View("AddressListBlade", viewModel));
}
/// <summary>
/// Get the view Model to display User information
/// </summary>
/// <returns>
/// The view model to display the User information
/// </returns>
public virtual async Task <UserMetadataViewModel> GetUserMetadataModel(GetUserMetadataParam param)
{
var urlParam = new BaseUrlParameter {
CultureInfo = param.CultureInfo
};
var customer = await CustomerRepository.GetCustomerByIdAsync(new GetCustomerByIdParam
{
CultureInfo = param.CultureInfo,
CustomerId = param.CustomerId,
Scope = param.Scope
}).ConfigureAwait(false);
var viewModel = ViewModelMapper.MapTo <UserMetadataViewModel>(customer, param.CultureInfo) ?? new UserMetadataViewModel();
viewModel.IsAuthenticated = param.IsAuthenticated;
viewModel.EncryptedCustomerId = param.EncryptedCustomerId;
viewModel.Url = viewModel.IsAuthenticated ? MyAccountUrlProvider.GetMyAccountUrl(urlParam) : MyAccountUrlProvider.GetLoginUrl(urlParam);
viewModel.RegisterUrl = MyAccountUrlProvider.GetCreateAccountUrl(urlParam);
return(viewModel);
}
public virtual ActionResult UpdateAccount()
{
var urlParam = new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
};
var changePasswordUrl = MyAccountUrlProvider.GetChangePasswordUrl(urlParam);
var addressListUrl = MyAccountUrlProvider.GetAddressListUrl(urlParam);
var param = new GetUpdateAccountViewModelParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
CustomerId = ComposerContext.CustomerId
};
var viewModel = CustomerViewService.GetUpdateAccountViewModelAsync(param).Result;
viewModel.ChangePasswordUrl = changePasswordUrl;
viewModel.AddressListUrl = addressListUrl;
return(View("UpdateAccountBlade", viewModel));
}
/// <summary>
/// Gets the <see cref="AddressListViewModel"/> to display a list of addresses in MyAddresses Form or Form result
/// </summary>
/// <param name="param"></param>
/// <param name="customer"></param>
/// <param name="addresses"></param>
/// <param name="regions"></param>
/// <returns></returns>
protected virtual AddressListViewModel GetAddressListViewModel(
GetAddressListViewModelParam param,
Customer customer,
IEnumerable <Address> addresses,
IEnumerable <RegionViewModel> regions)
{
var viewModel = ViewModelMapper.MapTo <AddressListViewModel>(customer, param.CultureInfo);
var urlParam = new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
};
var addAddressUrl = MyAccountUrlProvider.GetAddAddressUrl(urlParam);
var editAddressBaseUrl = MyAccountUrlProvider.GetUpdateAddressBaseUrl(urlParam);
viewModel.AddAddressUrl = addAddressUrl;
viewModel.Addresses = addresses.Select(address =>
{
var addressVm = ViewModelMapper.MapTo <AddressListItemViewModel>(address, param.CultureInfo);
if (!string.IsNullOrWhiteSpace(editAddressBaseUrl))
{
var editUrlWithParam = UrlFormatter.AppendQueryString(editAddressBaseUrl,
new NameValueCollection
{
{ "addressId", address.Id.ToString() }
});
addressVm.UpdateAddressUrl = editUrlWithParam;
}
var region = regions.FirstOrDefault(x => x.IsoCode == address.RegionCode);
addressVm.RegionName = region != null ? region.Name : string.Empty;
return(addressVm);
}).ToList();
return(viewModel);
}
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);
}
/// <summary>
/// Logs in a customer.
/// </summary>
/// <param name="loginParam">Service call params <see cref="LoginParam"/></param>
/// <returns>
/// The logged in Customer and a status representing a possible cause of errors
/// </returns>
public virtual async Task <LoginViewModel> LoginAsync(LoginParam loginParam)
{
if (loginParam == null)
{
throw new ArgumentNullException("loginParam");
}
if (loginParam.CultureInfo == null)
{
throw new ArgumentException("loginParam.CultureInfo");
}
if (string.IsNullOrWhiteSpace(loginParam.Password))
{
throw new ArgumentException("loginParam.Password");
}
if (string.IsNullOrWhiteSpace(loginParam.Username))
{
throw new ArgumentException("loginParam.Username");
}
if (string.IsNullOrWhiteSpace(loginParam.Scope))
{
throw new ArgumentException("loginParam.Scope");
}
var response = new CustomerAndStatus
{
Status = MyAccountStatus.Failed
};
var createAccountUrl = MyAccountUrlProvider.GetCreateAccountUrl(new BaseUrlParameter {
CultureInfo = loginParam.CultureInfo, ReturnUrl = loginParam.ReturnUrl
});
var forgotPasswordUrl = MyAccountUrlProvider.GetForgotPasswordUrl(new BaseUrlParameter {
CultureInfo = loginParam.CultureInfo, ReturnUrl = loginParam.ReturnUrl
});
var loginUrl = MyAccountUrlProvider.GetLoginUrl(new BaseUrlParameter {
CultureInfo = loginParam.CultureInfo, ReturnUrl = loginParam.ReturnUrl
});
var userName = GenerateUserName(loginParam.Username);
var loginResponse = Membership.LoginUser(userName, loginParam.Password);
if (loginResponse)
{
var user = Membership.GetUser(userName, true);
if (user != null && user.ProviderUserKey is Guid && !Guid.Empty.Equals(user.ProviderUserKey) && !user.IsLockedOut)
{
var customer = await CustomerRepository.GetCustomerByIdAsync(new GetCustomerByIdParam
{
CultureInfo = loginParam.CultureInfo,
Scope = loginParam.Scope,
CustomerId = (Guid)user.ProviderUserKey
}).ConfigureAwait(false);
var cartMergeParam = new CartMergeParam
{
Scope = loginParam.Scope,
GuestCustomerId = loginParam.GuestCustomerId,
LoggedCustomerId = customer.Id
};
await CartMergeProvider.MergeCartAsync(cartMergeParam).ConfigureAwait(false);
response.Customer = customer;
response.Status = MyAccountStatus.Success;
if (response.Customer.AccountStatus == AccountStatus.RequiresApproval)
{
response.Status = MyAccountStatus.RequiresApproval;
}
}
}
return(GetLoginViewModel(new GetLoginViewModelParam
{
ReturnUrl = loginParam.ReturnUrl,
Status = response.Status,
Username = userName,
CultureInfo = loginParam.CultureInfo,
Customer = response.Customer,
LoginUrl = loginUrl,
CreateAccountUrl = createAccountUrl,
ForgotPasswordUrl = forgotPasswordUrl
}));
}
