public void HandleEvent(BlogCommentApprovedEvent blogCommentEvent)
{
if (!_rewardPointsSettingsForBlogComments.IsEnabled)
{
return;
}
if (blogCommentEvent.BlogComment.Customer == null)
{
return;
}
//reward user only for the first approving
if (_genericAttributeService.GetAttribute <bool>(blogCommentEvent.BlogComment, "CustomerAwardedForBlogComment", blogCommentEvent.BlogComment.StoreId))
{
return;
}
//check whether delay is set
var activationDate = GetRewardPointsActivationDate(_rewardPointsSettingsForBlogComments);
//get message for the current customer
var languageId = _genericAttributeService.GetAttribute <int>(blogCommentEvent.BlogComment.Customer, NopCustomerDefaults.LanguageIdAttribute, blogCommentEvent.BlogComment.StoreId);
var message = _rewardPointsSettingsForBlogComments.GetLocalizedSetting(settings => settings.Message, languageId, blogCommentEvent.BlogComment.StoreId);
//add reward points for approved blog post comment
_rewardPointService.AddRewardPointsHistoryEntry(blogCommentEvent.BlogComment.Customer, _rewardPointsSettingsForBlogComments.Points,
blogCommentEvent.BlogComment.StoreId, string.Format(message, blogCommentEvent.BlogComment.BlogPost.Title), activatingDate: activationDate);
//mark that customer was already awarded for the comment
_genericAttributeService.SaveAttribute(blogCommentEvent.BlogComment, "CustomerAwardedForBlogComment", true, blogCommentEvent.BlogComment.StoreId);
}
/// <summary>
/// Executes a task
/// </summary>
public void Execute()
{
//find all settings of reward points that were to be awarded to the current date
var allPastAwardedPointsSettings = _rewardPointsOnDateSettingsService.GetAllRewardPointsOnDateSettings(date: DateTime.UtcNow);
//get not yet awarded
var notAwarded = allPastAwardedPointsSettings.Where(settings => !_genericAttributeService.GetAttribute <bool>(settings, "CustomersAwardedOnDate")).ToList();
//and now award it
foreach (var settings in notAwarded)
{
//find users with appropriate customer roles
var customerRoles = settings.CustomerRoleId > 0 ? new[] { settings.CustomerRoleId } : null;
var customers = _customerService.GetAllCustomers(customerRoleIds: customerRoles);
//get stores for which current awarding is actual
var storeIds = settings.StoreId > 0 || _rewardPointsSettings.PointsAccumulatedForAllStores
? new[] { settings.StoreId > 0 ? settings.StoreId : _storeContext.CurrentStore.Id }.ToList()
: _storeService.GetAllStores().Select(store => store.Id).ToList();
foreach (var storeId in storeIds)
{
foreach (var customer in customers)
{
//get localized message for appropriate customer
var languageId = _genericAttributeService.GetAttribute <int>(customer, NopCustomerDefaults.LanguageIdAttribute, storeId);
var message = _localizationService.GetLocalized(settings, setting => setting.Message, languageId);
//add reward points on specific date
_rewardPointService.AddRewardPointsHistoryEntry(customer, settings.Points, storeId, message);
}
}
//reward only once for each settings
_genericAttributeService.SaveAttribute(settings, "CustomersAwardedOnDate", true);
}
}
/// <summary>
/// Register customer
/// </summary>
/// <param name="request">Request</param>
/// <returns>Result</returns>
public virtual CustomerRegistrationResult RegisterCustomer(CustomerRegistrationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Customer == null)
{
throw new ArgumentException("Can't load current customer");
}
var result = new CustomerRegistrationResult();
if (request.Customer.IsSearchEngineAccount())
{
result.AddError("Search engine can't be registered");
return(result);
}
if (request.Customer.IsBackgroundTaskAccount())
{
result.AddError("Background task account can't be registered");
return(result);
}
if (request.Customer.IsRegistered())
{
result.AddError("Current customer is already registered");
return(result);
}
if (string.IsNullOrEmpty(request.Email))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailIsNotProvided"));
return(result);
}
if (!CommonHelper.IsValidEmail(request.Email))
{
result.AddError(_localizationService.GetResource("Common.WrongEmail"));
return(result);
}
if (string.IsNullOrWhiteSpace(request.Password))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.PasswordIsNotProvided"));
return(result);
}
if (_customerSettings.UsernamesEnabled && string.IsNullOrEmpty(request.Username))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameIsNotProvided"));
return(result);
}
//validate unique user
if (_customerService.GetCustomerByEmail(request.Email) != null)
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailAlreadyExists"));
return(result);
}
if (_customerSettings.UsernamesEnabled && _customerService.GetCustomerByUsername(request.Username) != null)
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameAlreadyExists"));
return(result);
}
//at this point request is valid
request.Customer.Username = request.Username;
request.Customer.Email = request.Email;
var customerPassword = new CustomerPassword
{
Customer = request.Customer,
PasswordFormat = request.PasswordFormat,
CreatedOnUtc = DateTime.UtcNow
};
switch (request.PasswordFormat)
{
case PasswordFormat.Clear:
customerPassword.Password = request.Password;
break;
case PasswordFormat.Encrypted:
customerPassword.Password = _encryptionService.EncryptText(request.Password);
break;
case PasswordFormat.Hashed:
var saltKey = _encryptionService.CreateSaltKey(QNetCustomerServiceDefaults.PasswordSaltKeySize);
customerPassword.PasswordSalt = saltKey;
customerPassword.Password = _encryptionService.CreatePasswordHash(request.Password, saltKey, _customerSettings.HashedPasswordFormat);
break;
}
_customerService.InsertCustomerPassword(customerPassword);
request.Customer.Active = request.IsApproved;
//add to 'Registered' role
var registeredRole = _customerService.GetCustomerRoleBySystemName(QNetCustomerDefaults.RegisteredRoleName);
if (registeredRole == null)
{
throw new QNetException("'Registered' role could not be loaded");
}
//request.Customer.CustomerRoles.Add(registeredRole);
request.Customer.AddCustomerRoleMapping(new CustomerCustomerRoleMapping {
CustomerRole = registeredRole
});
//remove from 'Guests' role
var guestRole = request.Customer.CustomerRoles.FirstOrDefault(cr => cr.SystemName == QNetCustomerDefaults.GuestsRoleName);
if (guestRole != null)
{
//request.Customer.CustomerRoles.Remove(guestRole);
request.Customer.RemoveCustomerRoleMapping(
request.Customer.CustomerCustomerRoleMappings.FirstOrDefault(mapping => mapping.CustomerRoleId == guestRole.Id));
}
//add reward points for customer registration (if enabled)
if (_rewardPointsSettings.Enabled && _rewardPointsSettings.PointsForRegistration > 0)
{
var endDate = _rewardPointsSettings.RegistrationPointsValidity > 0
? (DateTime?)DateTime.UtcNow.AddDays(_rewardPointsSettings.RegistrationPointsValidity.Value) : null;
_rewardPointService.AddRewardPointsHistoryEntry(request.Customer, _rewardPointsSettings.PointsForRegistration,
request.StoreId, _localizationService.GetResource("RewardPoints.Message.EarnedForRegistration"), endDate: endDate);
}
_customerService.UpdateCustomer(request.Customer);
return(result);
}
/// <summary>
/// Register customer
/// </summary>
/// <param name="request">Request</param>
/// <returns>Result</returns>
public virtual CustomerRegistrationResult RegisterCustomer(CustomerRegistrationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (request.Customer == null)
{
throw new ArgumentException("Can't load current customer");
}
var result = new CustomerRegistrationResult();
if (request.Customer.IsSearchEngineAccount())
{
result.AddError("Search engine can't be registered");
return(result);
}
if (request.Customer.IsBackgroundTaskAccount())
{
result.AddError("Background task account can't be registered");
return(result);
}
if (request.Customer.IsRegistered())
{
result.AddError("Current customer is already registered");
return(result);
}
if (String.IsNullOrEmpty(request.Email))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailIsNotProvided"));
return(result);
}
if (!CommonHelper.IsValidEmail(request.Email))
{
result.AddError(_localizationService.GetResource("Common.WrongEmail"));
return(result);
}
if (String.IsNullOrWhiteSpace(request.Password))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.PasswordIsNotProvided"));
return(result);
}
if (_customerSettings.UsernamesEnabled)
{
if (String.IsNullOrEmpty(request.Username))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameIsNotProvided"));
return(result);
}
}
//validate unique user
if (_customerService.GetCustomerByEmail(request.Email) != null)
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailAlreadyExists"));
return(result);
}
if (_customerSettings.UsernamesEnabled)
{
if (_customerService.GetCustomerByUsername(request.Username) != null)
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameAlreadyExists"));
return(result);
}
}
//at this point request is valid
request.Customer.Username = request.Username;
request.Customer.Email = request.Email;
request.Customer.PasswordFormat = request.PasswordFormat;
switch (request.PasswordFormat)
{
case PasswordFormat.Clear:
{
request.Customer.Password = request.Password;
}
break;
case PasswordFormat.Encrypted:
{
request.Customer.Password = _encryptionService.EncryptText(request.Password);
}
break;
case PasswordFormat.Hashed:
{
string saltKey = _encryptionService.CreateSaltKey(5);
request.Customer.PasswordSalt = saltKey;
request.Customer.Password = _encryptionService.CreatePasswordHash(request.Password, saltKey, _customerSettings.HashedPasswordFormat);
}
break;
default:
break;
}
request.Customer.Active = request.IsApproved;
//add to 'Registered' role
var registeredRole = _customerService.GetCustomerRoleBySystemName(SystemCustomerRoleNames.Registered);
if (registeredRole == null)
{
throw new NopException("'Registered' role could not be loaded");
}
request.Customer.CustomerRoles.Add(registeredRole);
//remove from 'Guests' role
var guestRole = request.Customer.CustomerRoles.FirstOrDefault(cr => cr.SystemName == SystemCustomerRoleNames.Guests);
if (guestRole != null)
{
request.Customer.CustomerRoles.Remove(guestRole);
}
//Add reward points for customer registration (if enabled)
if (_rewardPointsSettings.Enabled &&
_rewardPointsSettings.PointsForRegistration > 0)
{
_rewardPointService.AddRewardPointsHistoryEntry(request.Customer,
_rewardPointsSettings.PointsForRegistration,
request.StoreId,
_localizationService.GetResource("RewardPoints.Message.EarnedForRegistration"));
}
_customerService.UpdateCustomer(request.Customer);
return(result);
}
