public Result <CommerceUserModel> UpdateAccountInfo(CommerceUserModel user)
{
Assert.ArgumentNotNull(user, nameof(user));
var result = new Result <CommerceUserModel>();
ManagerResponse <GetUserResult, CommerceUser> getUserResponse =
this.accountManager.GetUser(user.ContactId);
if (!getUserResponse.ServiceProviderResult.Success || getUserResponse.Result == null)
{
result.SetErrors(getUserResponse.ServiceProviderResult);
return(result);
}
CommerceUser userForUpdate = getUserResponse.Result;
userForUpdate.FirstName = user.FirstName;
userForUpdate.LastName = user.LastName;
ManagerResponse <UpdateUserResult, CommerceUser> userUpdateResponse =
this.accountManager.UpdateUser(userForUpdate);
if (!userUpdateResponse.ServiceProviderResult.Success || userUpdateResponse.Result == null)
{
result.SetErrors(userUpdateResponse.ServiceProviderResult);
return(result);
}
result.SetResult(this.entityMapper.MapToCommerceUserModel(userUpdateResponse.Result));
return(result);
}
public override void Process(ServicePipelineArgs args)
{
ValidateArguments <CreateUserRequest, CreateUserResult>(args, out var request, out var result);
Assert.IsNotNull(request.UserName, "request.UserName");
Assert.IsNotNull(request.Password, "request.Password");
Container container = GetContainer(request.Shop.Name, string.Empty, "", "", args.Request.CurrencyCode,
new DateTime?());
CommerceUser commerceUser1 = result.CommerceUser;
if (commerceUser1 != null &&
commerceUser1.UserName.Equals(request.UserName, StringComparison.OrdinalIgnoreCase))
{
string entityId = "Entity-Customer-" + request.UserName;
ServiceProviderResult currentResult = new ServiceProviderResult();
EntityView entityView = GetEntityView(container, entityId, string.Empty, "Details", string.Empty,
currentResult);
if (currentResult.Success && !string.IsNullOrEmpty(entityView.EntityId))
{
base.Process(args);
return;
}
}
EntityView entityView1 =
GetEntityView(container, string.Empty, string.Empty, "Details", "AddCustomer", result);
if (!result.Success)
{
return;
}
entityView1.Properties.FirstOrDefault(p => p.Name.Equals("Domain")).Value = request.UserName.Split('\\')[0];
entityView1.Properties.FirstOrDefault(p => p.Name.Equals("LoginName")).Value =
request.UserName.Split('\\')[1];
entityView1.Properties.FirstOrDefault(p => p.Name.Equals("AccountStatus")).Value = "ActiveAccount";
if (!string.IsNullOrEmpty(request.Email))
{
entityView1.Properties.FirstOrDefault(p => p.Name.Equals("Email")).Value = request.Email;
}
CommerceCommand commerceCommand = DoAction(container, entityView1, result);
if (commerceCommand != null &&
commerceCommand.ResponseCode.Equals("ok", StringComparison.OrdinalIgnoreCase))
{
CommerceUser commerceUser2 = EntityFactory.Create <CommerceUser>("CommerceUser");
commerceUser2.Email = request.Email;
commerceUser2.UserName = request.UserName;
commerceUser2.ExternalId = commerceCommand.Models.OfType <CustomerAdded>().FirstOrDefault()?.CustomerId;
result.CommerceUser = commerceUser2;
request.Properties.Add(new PropertyItem()
{
Key = "UserId",
Value = result.CommerceUser.ExternalId
});
string entityId = "Entity-Customer-" + request.UserName;
TestSave(container, entityId, request, result, commerceUser2.ExternalId);
}
base.Process(args);
}
public EnableUserResult EnableUser(CommerceUser commerceUser)
{
Assert.ArgumentNotNull(commerceUser, nameof(commerceUser));
return(this.Execute(
new EnableUserRequest(commerceUser),
this.customerServiceProvider.EnableUser));
}
public MockVisitorContext(string userId, string userName, string visitorId, IContactFactory contactFactory = null, CommerceUser commerceUser = null)
{
ContactFactory = contactFactory;
UserId = userId;
UserName = userName;
CommerceUser = commerceUser;
VisitorId = visitorId;
}
/// <summary>
/// Initializes this object based on the data contained in the provided cart.
/// </summary>
/// <param name="user">The user.</param>
public virtual void Initialize(CommerceUser user)
{
Assert.ArgumentNotNull(user, "user");
this.FirstName = user.FirstName;
this.LastName = user.LastName;
this.FullName = string.Concat(this.FirstName, string.Empty, this.LastName);
this.Email = user.Email;
}
private CreateAccountResultModel MapToCreateAccountResultDto(
bool created,
string message,
CommerceUser commerceUser)
{
CommerceUserModel accountInfo = this.entityMapper.MapToCommerceUserModel(commerceUser);
return(new CreateAccountResultModel {
Created = created, Message = message, AccountInfo = accountInfo
});
}
private User MapToUser(CommerceUser commerceUser, string contactIdOrEmail)
{
if (commerceUser == null)
{
return(new User
{
ContactId = contactIdOrEmail
});
}
return(this.userMapper.Map <CommerceUser, User>(commerceUser));
}
public ManagerResponse <EnableUserResult, CommerceUser> EnableUser(CommerceUser commerceUser)
{
Assert.ArgumentNotNull(commerceUser, nameof(commerceUser));
var enableUserRequest = new EnableUserRequest(commerceUser);
var enableUserResult = this.customerServiceProvider.EnableUser(enableUserRequest);
if (!enableUserResult.Success)
{
Log.Warn("Enable user failed", this.GetType());
}
return(new ManagerResponse <EnableUserResult, CommerceUser>(enableUserResult, enableUserResult.CommerceUser));
}
public ManagerResponse <DisableUserResult, CommerceUser> DisableUser(CommerceUser commerceUser)
{
Assert.ArgumentNotNull(commerceUser, nameof(commerceUser));
var disableUserRequest = new DisableUserRequest(commerceUser);
DisableUserResult disableUserResult = this.customerServiceProvider.DisableUser(disableUserRequest);
if (!disableUserResult.Success)
{
Log.Warn("Disable user failed", this.GetType());
}
return(new ManagerResponse <DisableUserResult, CommerceUser>(disableUserResult, disableUserResult.CommerceUser));
}
public ManagerResponse <UpdateUserResult, CommerceUser> UpdateUser(CommerceUser updatedCommerceUser)
{
Assert.ArgumentNotNull(updatedCommerceUser, nameof(updatedCommerceUser));
var updateUserRequest = new UpdateUserRequest(updatedCommerceUser);
var updateUserResult = this.customerServiceProvider.UpdateUser(updateUserRequest);
if (!updateUserResult.Success)
{
Log.Warn("User update failed", this.GetType());
}
return(new ManagerResponse <UpdateUserResult, CommerceUser>(updateUserResult, updateUserResult.CommerceUser));
}
protected virtual void TranslateCommerceUserToView(EntityView view, CommerceUser commerceUser)
{
view.Properties.FirstOrDefault <ViewProperty>((Func <ViewProperty, bool>)(p => p.Name.Equals("UserName"))).Value = commerceUser.UserName;
view.Properties.FirstOrDefault <ViewProperty>((Func <ViewProperty, bool>)(p => p.Name.Equals("Email"))).Value = commerceUser.Email;
view.Properties.FirstOrDefault <ViewProperty>((Func <ViewProperty, bool>)(p => p.Name.Equals("AccountStatus"))).Value = commerceUser.IsDisabled ? "InactiveAccount" : "ActiveAccount";
view.Properties.FirstOrDefault <ViewProperty>((Func <ViewProperty, bool>)(p => p.Name.Equals("FirstName"))).Value = commerceUser.FirstName;
view.Properties.FirstOrDefault <ViewProperty>((Func <ViewProperty, bool>)(p => p.Name.Equals("LastName"))).Value = commerceUser.LastName;
string key = commerceUser.GetProperties().Keys.FirstOrDefault <string>((Func <string, bool>)(k => k.Equals("Phone", StringComparison.OrdinalIgnoreCase)));
if (string.IsNullOrWhiteSpace(key))
{
return;
}
view.Properties.FirstOrDefault <ViewProperty>((Func <ViewProperty, bool>)(p => p.Name.Equals("PhoneNumber"))).Value = commerceUser.GetPropertyValue(key).ToString();
}
/// <summary>
/// Resolve the CommerceUser from the Visitor
/// </summary>
/// <param name="user">The user.</param>
public void SetCommerceUser(CommerceUser user)
{
if (Tracker.Current == null || Tracker.Current.Contact == null || Tracker.Current.Contact.ContactId == Guid.Empty)
{
// This only occurs if we are authenticated but there is no ExternalUser assigned.
// This happens in preview mode we want to supply the default user to use in Preview mode
// Tracker.Visitor.ExternalUser = "******";
return;
}
Assert.IsNotNull(this.ContactFactory, "this.ContactFactory should not be null.");
this._commerceUser = user;
Assert.IsNotNull(this._commerceUser.Customers, "The user '{0}' does not contain a Customers collection.", user.UserName);
this._userId = this._commerceUser.Customers.FirstOrDefault();
}
protected void AssociateSitecoreUserWithCommerceUser(CommerceUser commerceUser, UserProfile sitecoreUser)
{
var externalId = sitecoreUser[Commerce.Constants.Profile.SitecoreProfile.UserId];
Assert.IsNotNullOrEmpty(externalId, $"The external id for the user {sitecoreUser.UserName} is empty.");
commerceUser.ExternalId = externalId;
if (commerceUser.Customers != null && commerceUser.Customers.Count != 0)
{
return;
}
var customers = new List <string> {
commerceUser.ExternalId
};
commerceUser.Customers = customers.AsReadOnly();
}
private UpdateUserResult InitUpdateUser(CommerceUser commerceUser, bool updateResultSuccess)
{
var updateResult = this.fixture
.Build <UpdateUserResult>()
.With(cu => cu.Success, updateResultSuccess)
.With(eu => eu.CommerceUser, commerceUser)
.Create();
if (!updateResultSuccess)
{
updateResult.SystemMessages.Add(this.fixture.Create <SystemMessage>());
}
this.accountManager
.UpdateUser(commerceUser)
.Returns(updateResult);
return(updateResult);
}
private CommerceUserModel MapToCommerceUserModel(CommerceUser commerceUser, string contactIdOrEmail)
{
if (commerceUser == null)
{
return(new CommerceUserModel {
ContactId = contactIdOrEmail
});
}
string customerId = this.GetCustomerId(commerceUser?.Customers);
string contactId = this.ParseContactId(commerceUser?.ExternalId);
return(new CommerceUserModel
{
ContactId = contactId,
CustomerId = customerId,
Email = commerceUser.Email,
FirstName = commerceUser.FirstName,
LastName = commerceUser.LastName,
UserName = commerceUser.UserName
});
}
public void SetCommerceUser(CommerceUser user)
{
}
/// <summary>
/// Initializes the specified user.
/// </summary>
/// <param name="user">The user.</param>
public virtual void Initialize(CommerceUser user)
{
this.UserName = user.UserName;
}
/// <summary>
/// Resolve the CommerceUser from the Visitor
/// </summary>
/// <param name="user">The user.</param>
public void SetCommerceUser(CommerceUser user)
{
if (Tracker.Current == null || Tracker.Current.Contact == null || Tracker.Current.Contact.ContactId == Guid.Empty)
{
// This only occurs if we are authenticated but there is no ExternalUser assigned.
// This happens in preview mode we want to supply the default user to use in Preview mode
// Tracker.Visitor.ExternalUser = "******";
return;
}
Assert.IsNotNull(this.ContactFactory, "this.ContactFactory should not be null.");
this._commerceUser = user;
Assert.IsNotNull(this._commerceUser.Customers, "The user '{0}' does not contain a Customers collection.", user.UserName);
this._userId = this._commerceUser.Customers.FirstOrDefault();
}
public CommerceUserModel MapToCommerceUserModel(CommerceUser x)
{
return(this.innerMapper.Map <CommerceUserModel>(x));
}
/// <summary>
/// Initializes the specified user.
/// </summary>
/// <param name="user">The user.</param>
public virtual void Initialize(CommerceUser user)
{
this.UserName = user.UserName;
}
/// <summary>
/// Initializes this object based on the data contained in the provided cart.
/// </summary>
/// <param name="user">The user.</param>
public virtual void Initialize(CommerceUser user)
{
Assert.ArgumentNotNull(user, "user");
this.FirstName = user.FirstName;
this.LastName = user.LastName;
this.FullName = string.Concat(this.FirstName, string.Empty, this.LastName);
this.Email = user.Email;
}
public Result <CreateAccountResultModel> CreateAccount(CreateAccountModel createAccountModel)
{
Assert.ArgumentNotNull(createAccountModel, nameof(createAccountModel));
string firstName = createAccountModel.FirstName;
Assert.ArgumentNotNullOrEmpty(firstName, nameof(firstName));
string lastName = createAccountModel.LastName;
Assert.ArgumentNotNullOrEmpty(lastName, nameof(lastName));
string userName = $"{firstName}{lastName}{Guid.NewGuid():N}";
string email = createAccountModel.Email;
Assert.ArgumentNotNullOrEmpty(email, nameof(email));
string password = createAccountModel.Password;
Assert.ArgumentNotNull(password, nameof(password));
string shopName = this.storefrontContext.ShopName;
Assert.ArgumentNotNull(shopName, nameof(shopName));
var result = new Result <CreateAccountResultModel>();
Result <ValidateAccountResultModel> validateAccountResult =
this.ValidateAccount(new ValidateAccountModel {
Email = email
});
if (!validateAccountResult.Success)
{
result.SetErrors(validateAccountResult.Errors);
return(result);
}
if (validateAccountResult.Success && validateAccountResult.Data.Invalid)
{
var message = validateAccountResult.Data.InUse
? "Email is already in use"
: "Email is invalid";
result.SetError(message);
return(result);
}
ManagerResponse <CreateUserResult, CommerceUser> createUserResult =
this.accountManager.CreateUser(userName, email, password, shopName);
if (!createUserResult.ServiceProviderResult.Success)
{
result.SetError("Error is occured during user account creation");
result.SetResult(new CreateAccountResultModel()
{
Created = false, Message = string.Empty
});
return(result);
}
CommerceUser createdCommerceUser = createUserResult.Result;
ManagerResponse <EnableUserResult, CommerceUser> enableUserResult =
this.accountManager.EnableUser(createdCommerceUser);
CommerceUser user = enableUserResult.Result ?? createdCommerceUser;
//set user data
user.FirstName = createAccountModel.FirstName;
user.LastName = createAccountModel.LastName;
var updateResult = this.accountManager.UpdateUser(user);
result.SetResult(this.MapToCreateAccountResultDto(true, "Created", updateResult.Result));
return(result);
}
