/// <summary>
/// Creates and persists a Member
/// </summary>
/// <remarks>
/// Using this method will persist the Member object before its returned
/// meaning that it will have an Id available (unlike the CreateMember method)
/// </remarks>
/// <param name="username">Username of the Member to create</param>
/// <param name="email">Email of the Member to create</param>
/// <param name="passwordValue">
/// This value should be the encoded/encrypted/hashed value for the password that will be
/// stored in the database
/// </param>
/// <param name="isApproved">Is the user approved</param>
/// <returns>
/// <see cref="IUser" />
/// </returns>
private IUser CreateUserWithIdentity(string username, string email, string passwordValue, bool isApproved = true)
{
if (username == null)
{
throw new ArgumentNullException(nameof(username));
}
if (string.IsNullOrWhiteSpace(username))
{
throw new ArgumentException(
"Value can't be empty or consist only of white-space characters.",
nameof(username));
}
EventMessages evtMsgs = EventMessagesFactory.Get();
// TODO: PUT lock here!!
User user;
using (ICoreScope scope = ScopeProvider.CreateCoreScope())
{
var loginExists = _userRepository.ExistsByLogin(username);
if (loginExists)
{
throw new ArgumentException("Login already exists"); // causes rollback
}
user = new User(_globalSettings)
{
Email = email,
Language = _globalSettings.DefaultUILanguage,
Name = username,
RawPasswordValue = passwordValue,
Username = username,
IsLockedOut = false,
IsApproved = isApproved,
};
var savingNotification = new UserSavingNotification(user, evtMsgs);
if (scope.Notifications.PublishCancelable(savingNotification))
{
scope.Complete();
return(user);
}
_userRepository.Save(user);
scope.Notifications.Publish(new UserSavedNotification(user, evtMsgs).WithStateFrom(savingNotification));
scope.Complete();
}
return(user);
}
/// <summary>
/// Saves an <see cref="IUser" />
/// </summary>
/// <param name="entity"><see cref="IUser" /> to Save</param>
public void Save(IUser entity)
{
EventMessages evtMsgs = EventMessagesFactory.Get();
using (ICoreScope scope = ScopeProvider.CreateCoreScope())
{
var savingNotification = new UserSavingNotification(entity, evtMsgs);
if (scope.Notifications.PublishCancelable(savingNotification))
{
scope.Complete();
return;
}
if (string.IsNullOrWhiteSpace(entity.Username))
{
throw new ArgumentException("Empty username.", nameof(entity));
}
if (string.IsNullOrWhiteSpace(entity.Name))
{
throw new ArgumentException("Empty name.", nameof(entity));
}
try
{
_userRepository.Save(entity);
scope.Notifications.Publish(
new UserSavedNotification(entity, evtMsgs).WithStateFrom(savingNotification));
scope.Complete();
}
catch (DbException ex)
{
// if we are upgrading and an exception occurs, log and swallow it
if (IsUpgrading == false)
{
throw;
}
_logger.LogWarning(
ex,
"An error occurred attempting to save a user instance during upgrade, normally this warning can be ignored");
// we don't want the uow to rollback its scope!
scope.Complete();
}
}
}
/// <summary>
/// Saves a list of <see cref="IUser" /> objects
/// </summary>
/// <param name="entities"><see cref="IEnumerable{IUser}" /> to save</param>
public void Save(IEnumerable <IUser> entities)
{
EventMessages evtMsgs = EventMessagesFactory.Get();
IUser[] entitiesA = entities.ToArray();
using (ICoreScope scope = ScopeProvider.CreateCoreScope())
{
var savingNotification = new UserSavingNotification(entitiesA, evtMsgs);
if (scope.Notifications.PublishCancelable(savingNotification))
{
scope.Complete();
return;
}
foreach (IUser user in entitiesA)
{
if (string.IsNullOrWhiteSpace(user.Username))
{
throw new ArgumentException("Empty username.", nameof(entities));
}
if (string.IsNullOrWhiteSpace(user.Name))
{
throw new ArgumentException("Empty name.", nameof(entities));
}
_userRepository.Save(user);
}
scope.Notifications.Publish(
new UserSavedNotification(entitiesA, evtMsgs).WithStateFrom(savingNotification));
// commit the whole lot in one go
scope.Complete();
}
}
