public async Task SendUserActivation(string recipient, UserActivationModel model)
{
string body = _templateProvider.Load(model);
string subject = string.Format("Activate your account at {0}", model.ProductName);
await Send(recipient, subject, body, model.Sender);
}
public void ForgotPassword(string email)
{
ValidationResult validationResult;
if (!this.IsValid(new ForgetPasswordViewModel {
Email = email
}, out validationResult))
{
var error = this.GenerateValidationError(validationResult);
this.LogError("User.ForgotPassword", error);
throw new FaultException <Error>(error, error.errorMessage);
}
User user = this.UserModel.GetOneByEmail(email).Value;
UserActivationModel model = this.UserActivationModel;
UserActivation userActivation;
if ((userActivation = model.GetLatestByUser(user.Id).Value) == null)
{
userActivation = UserActivation.Build(user);
model.RegisterSave(userActivation);
}
user.Status = UserStatus.Active;
this.UserModel.RegisterSave(user);
this.SendActivationLinkEmail(user.FirstName, user.Email, userActivation.ActivationCode);
}
public HomeController(UserModel userModel, UserActivationModel userActivationModel, ApplicationSettingsProvider settings, IBuildVersionProcessor versionProcessor)
: base(settings)
{
_userModel = userModel ?? throw new ArgumentNullException(nameof(userModel));
_userActivationModel = userActivationModel ?? throw new ArgumentNullException(nameof(userActivationModel));
_versionProcessor = versionProcessor ?? throw new ArgumentNullException(nameof(versionProcessor));
}
public ActionResult Activate(UserActivationModel model)
{
dynamic metadata = JWT.JsonWebToken.DecodeToObject(model.UserToken,
ConfigurationManager.AppSettings["analystick:signingKey"], true);
if (metadata == null)
{
return(View("ActivationError",
new UserActivationErrorModel("Unable to find the token.")));
}
if (!ModelState.IsValid)
{
return(View(model));
}
UserProfile user = GetUserProfile(metadata["id"]);
if (user != null)
{
if (user.ExtraProperties.ContainsKey("activation_pending") && !((bool)user.ExtraProperties["activation_pending"]))
{
return(View("ActivationError", new UserActivationErrorModel("Error activating user, the user is already active.")));
}
_client.ChangePassword(user.UserId, model.Password, false);
_client.UpdateUserMetadata(user.UserId, new { activation_pending = false });
return(View("Activated"));
}
return(View("ActivationError",
new UserActivationErrorModel("Error activating user, could not find an exact match for this email address.")));
}
/// <summary>
/// The activate.
/// </summary>
/// <param name="activationCode">
/// The activation code.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public string Activate(string activationCode)
{
var arr = UserActivationModel.GetOneByCode(activationCode).Value;
if (arr == null)
{
var error = new Error(
Errors.CODE_ERRORTYPE_USER_INACTIVE,
ErrorsTexts.UserActivationError_Subject,
ErrorsTexts.UserActivationError_InvalidActivationCode);
this.LogError("Rest.Activate", error);
throw new FaultException <Error>(error, error.errorMessage);
}
if (arr.DateExpires < DateTime.Now)
{
var error = new Error(
Errors.CODE_ERRORTYPE_USER_INACTIVE,
ErrorsTexts.UserActivationError_Subject,
ErrorsTexts.UserActivationError_InvalidActivationCode);
this.LogError("Rest.Activate", error);
throw new FaultException <Error>(error, error.errorMessage);
}
var user = arr.User;
user.Status = UserStatus.Active;
user.DateModified = DateTime.Now;
UserActivationModel model = this.UserActivationModel;
UserActivation userActivation;
if ((userActivation = model.GetLatestByUser(user.Id).Value) == null)
{
userActivation = UserActivation.Build(user);
model.RegisterSave(userActivation);
}
UserModel.RegisterSave(user);
//IoC.Resolve<RealTimeNotificationModel>()
// .NotifyClientsAboutChangesInTable<User>(NotificationType.Update, user.Company.Id, user.Id);
UserActivationModel.RegisterDelete(arr);
this.SendActivationLinkEmail(user.FirstName, user.Email, userActivation.ActivationCode);
if (WebOperationContext.Current != null)
{
var response = WebOperationContext.Current.OutgoingResponse;
response.StatusCode = HttpStatusCode.Redirect;
response.Headers.Add(HttpResponseHeader.Location, (string)this.Settings.BasePath);
}
return(null);
}
protected void SendActivation(User user)
{
UserActivationModel model = this.UserActivationModel;
UserActivation userActivation;
List <MailAddress> bcced = null;
if ((userActivation = model.GetLatestByUser(user.Id).Value) == null)
{
userActivation = UserActivation.Build(user);
model.RegisterSave(userActivation);
bcced = GetBCCed(this.Settings.BCCNewEmail as string);
}
SendActivationEmail(user.FirstName, user.Email, user.Company, userActivation.ActivationCode, bcced);
}
public async Task <ActionResult> Activate(UserActivationModel model)
{
dynamic metadata = JWT.JsonWebToken.DecodeToObject(model.UserToken,
ConfigurationManager.AppSettings["analystick:signingKey"], true);
if (metadata == null)
{
return(View("ActivationError",
new UserActivationErrorModel("Unable to find the token.")));
}
if (!ModelState.IsValid)
{
return(View(model));
}
User user = await GetUserProfile(metadata["id"]);
if (user != null)
{
if (user.AppMetadata["activation_pending"] != null && !((bool)user.AppMetadata["activation_pending"]))
{
return(View("ActivationError", new UserActivationErrorModel("Error activating user, the user is already active.")));
}
var client = await GetApiClient();
await client.Users.UpdateAsync(user.UserId, new UserUpdateRequest {
Password = model.Password
});
await client.Users.UpdateAsync(user.UserId, new UserUpdateRequest
{
AppMetadata = new { activation_pending = false }
});
return(View("Activated"));
}
return(View("ActivationError",
new UserActivationErrorModel("Error activating user, could not find an exact match for this email address.")));
}
public async Task <IActionResult> Activate(UserActivationModel model)
{
dynamic metadata = JWT.JsonWebToken.DecodeToObject(model.UserToken, _analystickConfig.Value.SigningKey);
if (metadata == null)
{
return(View("ActivationError",
new UserActivationErrorModel("Unable to find the token.")));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await GetUserProfile(metadata["id"]);
if (user.UserId != null)
{
if (user.UserMetadata != null && !((bool)user.UserMetadata["activation_pending"]))
{
return(View("ActivationError", new UserActivationErrorModel("Error activating user, the user is already active.")));
}
_usersClient.Update(user.UserId, new UserUpdateRequest()
{
Password = model.Password,
UserMetadata = new
{
activation_pending = false
}
});
return(View("Activated"));
}
return(View("ActivationError",
new UserActivationErrorModel("Error activating user, could not find an exact match for this email address.")));
}
public ActionResult Activate(UserActivationModel model)
{
bool hasLocker = false;
try
{
Monitor.Enter(locker, ref hasLocker);
UserProfileModel user = null;
if (ModelState.IsValid)
{
user = db.UserProfiles.FirstOrDefault(u => u.Name.Equals(model.UserName, StringComparison.OrdinalIgnoreCase) &&
u.Token.Equals(model.Token, StringComparison.OrdinalIgnoreCase));
}
if (user == null)
{
ModelState.AddModelError(String.Empty, "Пользователь не найден");
}
if (ModelState.IsValid)
{
user.SetPassword(model.Password);
user.PasswordTokenExpirationTime = null;
user.Token = String.Empty;
user.Inactive = false;
db.SaveChanges();
return(RedirectToAction("Login", new { returnUrl = String.Empty, result = DbResult.Updated }));
}
else
{
return(View(model));
}
}
finally
{
if (hasLocker)
{
Monitor.Exit(locker);
}
}
}
public ActionResult Activate(String id)
{
var userToActivate = db.UserProfiles.FirstOrDefault(u => u.Token.Equals(id, StringComparison.OrdinalIgnoreCase));
if (userToActivate == null)
{
return(new HttpNotFoundResult("Пользователь не найден"));
}
//public ActionResult ForgottenPassword(string initialName = null, ValidateStatusMessage message = ValidateStatusMessage.Nothing)
if (!userToActivate.Inactive && userToActivate.PasswordTokenExpirationTime != null && userToActivate.PasswordTokenExpirationTime < DateTime.UtcNow)
{
return(RedirectToAction("ForgottenPassword", new { initialName = userToActivate.Name, message = ValidateStatusMessage.Expired }));
}
UserActivationModel model = new UserActivationModel {
UserName = userToActivate.Name,
Password = String.Empty,
PasswordConfirm = String.Empty,
Token = userToActivate.Token
};
return(View(model));
}
public CompanyDTO Save(CompanyDTO dto)
{
ValidationResult validationResult;
if (!this.IsValid(dto, out validationResult))
{
var error = this.GenerateValidationError(validationResult);
this.LogError("Company.Save", error);
throw new FaultException <Error>(error, error.errorMessage);
}
var companyModel = this.CompanyModel;
var companyLicenseModel = this.CompanyLicenseModel;
var instance = (dto.companyId == 0)
? null
: companyModel.GetOneById(dto.companyId).Value;
instance = this.Convert(dto, instance);
var isTransient = instance.IsTransient();
companyModel.RegisterSave(instance, true);
if (isTransient && dto.licenseVO != null)
{
var user = this.UserModel.GetOneById(dto.licenseVO.createdBy).Value;
var license = instance.CurrentLicense ?? new CompanyLicense();
license.Company = instance;
var licenseIsTransient = license.IsTransient();
if (licenseIsTransient)
{
license.CreatedBy = user;
license.DateCreated = DateTime.Now;
}
license.ModifiedBy = user;
license.DateModified = DateTime.Now;
var expiryDate = dto.licenseVO.expiryDate.ConvertFromUnixTimeStamp();
license.ExpiryDate = expiryDate < DateTime.Now || expiryDate == DateTime.MinValue ? dto.licenseVO.isTrial ? DateTime.Now.AddDays(30) : DateTime.Now.AddYears(1) : expiryDate;
var start = dto.licenseVO.startDate.ConvertFromUnixTimeStamp();
license.DateStart = start < DateTime.Now || start == SqlDateTime.MinValue.Value ? DateTime.Now : dto.licenseVO.startDate.ConvertFromUnixTimeStamp();
license.LicenseStatus = GetLicenseStatus(dto.licenseVO);
license.TotalLicensesCount = dto.licenseVO.totalLicensesCount;
license.TotalParticipantsCount = dto.licenseVO.totalParticipantsCount == 0 ? 100 : dto.licenseVO.totalParticipantsCount;
license.Domain = dto.licenseVO.domain;
license.LicenseNumber = Guid.NewGuid().ToString();
companyLicenseModel.RegisterSave(license);
if (licenseIsTransient)
{
instance.Licenses.Add(license);
companyModel.RegisterSave(instance, false);
}
}
if ((!dto.primaryContactId.HasValue || dto.primaryContactId == default(int)) && dto.primaryContactVO != null)
{
bool passwordChanged, emailChanged;
var user = this.ProcessPrimaryContact(dto, instance, out passwordChanged, out emailChanged);
var isUserTransient = user.IsTransient();
user.Company = instance;
UserModel.RegisterSave(user);
//IoC.Resolve<RealTimeNotificationModel>().NotifyClientsAboutChangesInTable<User>(NotificationType.Update, user.Company.Id, user.Id);
instance.PrimaryContact = user;
companyModel.RegisterSave(instance, true);
if (isUserTransient)
{
UserActivationModel model = this.UserActivationModel;
UserActivation userActivation;
if ((userActivation = model.GetLatestByUser(user.Id).Value) == null)
{
userActivation = UserActivation.Build(user);
model.RegisterSave(userActivation);
}
var license = instance.Licenses.FirstOrDefault();
if (license.Return(x => x.LicenseStatus == CompanyLicenseStatus.Trial, false))
{
user.Status = UserStatus.Active;
UserModel.RegisterSave(user);
this.SendTrialEmail(user, userActivation.ActivationCode, instance);
}
else if (license.Return(x => x.LicenseStatus == CompanyLicenseStatus.Enterprise, false))
{
user.Status = UserStatus.Active;
UserModel.RegisterSave(user);
this.SendEnterpriseEmail(user, userActivation.ActivationCode, instance);
}
else
{
this.SendActivation(user);
}
}
else if (passwordChanged || emailChanged)
{
UserActivationModel model = this.UserActivationModel;
UserActivation userActivation;
if ((userActivation = model.GetLatestByUser(user.Id).Value) == null)
{
userActivation = UserActivation.Build(user);
model.RegisterSave(userActivation);
}
this.SendActivationLinkEmail(user.FirstName, user.Email, userActivation.ActivationCode);
}
}
else if (instance.PrimaryContact == null)
{
foreach (var companyLicense in instance.Licenses)
{
companyLicenseModel.RegisterDelete(companyLicense);
}
companyModel.RegisterDelete(instance);
companyModel.Flush();
var errorRes = new Error(Errors.CODE_ERRORTYPE_GENERIC_ERROR, "CompanyWithoutContact", "Company was created without primary contact");
throw new FaultException <Error>(errorRes, errorRes.errorMessage);
}
//IoC.Resolve<RealTimeNotificationModel>().NotifyClientsAboutChangesInTable<Company>(NotificationType.Update, instance.Id, instance.Id);
var dtoResult = new CompanyDTO(instance);
var lmses = isTransient ? LmsCompanyModel.GetAllByCompanyId(instance.Id).ToList() : new List <LmsCompany>();
var lms = lmses.FirstOrDefault();
if (lms == null)
{
dtoResult.lmsVO = new CompanyLmsDTO();
}
else
{
LmsProvider lmsProvider = LmsProviderModel.GetById(lms.LmsProviderId);
dtoResult.lmsVO = new CompanyLmsDTO(lms, lmsProvider, Settings);
}
return(dtoResult);
}
public IHttpActionResult Activate(UserActivationModel activationModel)
{
const string contextName = "activate";
if (string.IsNullOrEmpty(activationModel.ActivationCode))
{
return(RespondFailure("Invalid activation code", contextName));
}
if (_userSettings.RequireEmailForUserActivation && string.IsNullOrEmpty(activationModel.Email))
{
return(RespondFailure("Invalid email", contextName));
}
//let's see if we have correct activation code
if (_userSettings.RequireEmailForUserActivation)
{
//let's find the user who has this email
var user = _userService.FirstOrDefault(x => x.Email == activationModel.Email);
if (user == null)
{
return(RespondFailure("The email is not registered", contextName));
}
if (user.Active)
{
return(RespondFailure("The user is already active", contextName));
}
//get the activation code and verify if it's same
var savedActivationCode = user.GetPropertyValueAs <string>(PropertyNames.ActivationCode);
if (string.Compare(activationModel.ActivationCode, savedActivationCode, StringComparison.Ordinal) != 0)
{
return(RespondFailure("Invalid activation code", contextName));
}
//activate the user now
user.Active = true;
_userService.Update(user);
//delete the activation code as well
user.DeleteProperty(PropertyNames.ActivationCode);
//send notification
_emailSender.SendUserActivatedMessage(user);
return(RespondSuccess("Your email has been successfully verified", contextName));
}
else
{
//we just need to find a user whose activation code matches with provided code and mark it active
var property = _entityPropertyService.FirstOrDefault(
x =>
x.PropertyName == PropertyNames.ActivationCode && x.Value == activationModel.ActivationCode &&
x.EntityName == typeof(User).Name);
if (property == null)
{
return(RespondFailure("Invalid activation code", contextName));
}
//get the user with this property
var user = _userService.Get(property.EntityId);
if (user == null)
{
return(RespondFailure("The user account doesn't exist or has been deleted", contextName));
}
if (user.Active)
{
return(RespondFailure("The user is already active", contextName));
}
//mark the user as active
user.Active = true;
_userService.Update(user);
//delete the activation code as well
user.DeleteProperty(PropertyNames.ActivationCode);
//send notification
_emailSender.SendUserActivatedMessage(user);
return(RespondSuccess("Your email has been successfully verified", contextName));
}
}
public async Task <RegistrationResponse> UserRegistration(RegisterUserModelDto modelDto)
{
RegistrationResponse resp;
if (modelDto == null)
{
throw new ArgumentNullException(nameof(modelDto));
}
var isEmailTaken = await CheckUserExists(e => e.EmailAddress.Equals(modelDto.EmailAddress));
if (isEmailTaken != null)
{
// if email is already taken
resp = new RegistrationResponse
{
IsEmailTaken = true,
IsSucceeded = false,
};
return(resp);
}
//transaction
using (var _savieTransaction = _userProfileDbContext.Database.BeginTransaction())
{
//create password encrypt
CreatePasswordEncrypt(modelDto.Pasword, out byte[] passwordHash, out byte[] passwordSalt);
var user = new UserModel
{
Firstname = modelDto.Firstname,
Lastname = modelDto.Lastname,
EmailAddress = modelDto.EmailAddress,
PhoneNo = modelDto.PhoneNo,
Password = modelDto.Pasword,
ReferredBy = modelDto.ReferredBy,
PaswordHash = passwordHash,
PasswordSalt = passwordSalt,
DateCreated = DateTime.UtcNow,
IsActivated = false,
IsActive = false,
};
await _userProfileDbContext.AddAsync(user);
await _userProfileDbContext.SaveChangesAsync();
if (user.Id > 0)
{
//if user registration succeeds and email not taken
var rnd = new Random();
var rnd1 = rnd.Next(10, 99);
var rnd2 = rnd.Next(100, 999);
var rnd3 = rnd.Next(1000, 9999);
var code = rnd3 + user.EmailAddress.Substring(3, 5).ToUpper() + rnd2 + rnd1;
var name = user.Firstname;
if (user.EmailAddress != null && user.PhoneNo != null)
{
var activationCode = new UserActivationModel
{
ActivationCode = code,
SentOn = DateTime.UtcNow,
ExpiresAt = DateTime.UtcNow.AddMinutes(5),//expires after 5 Minutes
ActivatedOn = null,
ComfirmedActivation = false,
UserModelId = user.Id,
};
//save the activation code
await _userProfileDbContext.UserActivationModel.AddAsync(activationCode);
await _userProfileDbContext.SaveChangesAsync();
}
_savieTransaction.Commit();
// await Task.Run(() => _notification.SendActivationCodeBySMS(name, code, user.PhoneNo));
await Task.Run(() => _notification.SendActivationCodeByMail(name, code, user.EmailAddress));
resp = new RegistrationResponse
{
IsSucceeded = true,
IsEmailTaken = false,
};
return(resp);
}
}
// if user registraion fails
return(null);
}
