示例#1
0
        public ActionResult AccountActivation(string token)
        {
            var customerId = _workContext.CurrentCustomer.Id;

            var cToken = _smsNotificationService.GetActivationCode(customerId);

            if (String.IsNullOrEmpty(cToken))
            {
                return(RedirectToRoute("HomePage"));
            }

            if (!cToken.Equals(token, StringComparison.InvariantCultureIgnoreCase))
            {
                return(RedirectToRoute("HomePage"));
            }

            var smsRecord = _smsNotificationService.GetByCustomerId(customerId);

            smsRecord.Active = true;
            _smsNotificationService.UpdateSMSRecord(smsRecord);

            var model = new AccountActivationModel();
            //BUGFIX 3.811
            var referrer = TempData["Referrer"];

            model.CustomProperties.Add("Referrer", referrer);

            model.Result = _localizationService.GetResource("Account.ValidatePhone.Validated"); //NOP 3.825
            return(View("AccountActivation", model));
        }
 public IHttpActionResult ConfirmUser([FromUri] AccountActivationModel model)
 {
     Response.Message    = Messages.SucessMessage;
     Response.Response   = null;
     Response.StatusCode = HttpStatusCode.OK;
     UserService.ConfirmUser(model);
     return(Ok(Response));
 }
示例#3
0
        public virtual IActionResult AccountActivation(string token, string email)
        {
            var user = _userService.GetUserByEmail(email);

            if (user == null)
            {
                return(RedirectToAction("Login", "User"));
            }

            var userAccountActivationAttribute = _genericAttributeService.GetAttributesForEntityByToken(user.Id, nameof(user), ResearchUserDefaults.AccountActivationTokenAttribute)
                                                 .Where(x => x.Value.Contains(token)).FirstOrDefault();
            string cToken     = userAccountActivationAttribute != null ? userAccountActivationAttribute.Value : string.Empty;
            var    researcher = _researcherService.GetResearcherByEmail(email);

            if (researcher.IsCompleted)
            {
                return
                    (View(new AccountActivationModel
                {
                    Result = "ระบบยืนยันอีเมลของเท่านเรียบร้อยแล้ว โปรดล็อคอินเข้าสู่ระบบ !"
                }));
            }

            //if (!cToken.Equals(token, StringComparison.InvariantCultureIgnoreCase))
            if (string.IsNullOrEmpty(cToken))
            {
                return(RedirectToAction("Login", "User"));
            }

            //activate researcher account
            researcher.IsCompleted = true;
            researcher.Modified    = DateTime.UtcNow;
            _researcherService.UpdateResearcher(researcher);
            user.Modified = DateTime.UtcNow;
            _userService.UpdateUser(user);
            _genericAttributeService.SaveAttribute(user, ResearchUserDefaults.AccountActivationTokenAttribute, "");

            //send welcome message
            _workflowMessageService.SendUserWelcomeMessage(user, 0);

            var model = new AccountActivationModel
            {
                Result = "ยินดีต้อนรับเข้าสู่ระบบสารสนเทศเพื่อการบริหารงานวิจัย ระบบได้ยืนยันอีเมลของเท่าน โปรดล็อคอินเข้าสู่ระบบ !"
            };

            return(View(model));
        }
 public async Task <GenericResponseModel <AccountActivationModel> > AccountConfirmation([FromUri] string token)
 {
     return(await Task.Run(async() => {
         var accountActivation = new AccountActivationModel();
         try {
             ErrorCode = "800.91";
             var response = await accountService.ValidateActivationPasscodeToken(token);
             response.Item1.Password = string.Empty;
             accountActivation = new AccountActivationModel {
                 Username = response.Item1.Username, IsValidated = response.Item2, Message = response.Item3
             };
         } catch (Exception ex) {
             string message = ex.Message + (!string.IsNullOrEmpty(ex.InnerException.Message) && ex.Message != ex.InnerException.Message ? " Reason : " + ex.InnerException.Message : string.Empty);
             ErrorDetails.Add(message);
             ErrorMessage = message;
             MethodBase methodBase = MethodBase.GetCurrentMethod();
             StackTrace trace = new StackTrace(ex, true);
             string sourceFile = trace.GetFrame(0).GetFileName();
             await ErrorLogs.Write(new ErrorLogsModel {
                 Application = Assembly.GetExecutingAssembly().GetName().Name,
                 Controller = GetType().Name,
                 CurrentAction = methodBase.Name.Split('>')[0].TrimStart('<'),
                 ErrorCode = ErrorCode,
                 Message = message,
                 SourceFile = sourceFile,
                 LineNumber = trace.GetFrame(0).GetFileLineNumber(),
                 StackTrace = ex.ToString(),
                 Method = methodBase.Name.Split('>')[0].TrimStart('<')
             }, ex);
             accountActivation = new AccountActivationModel {
                 Username = string.Empty, IsValidated = false, Message = message
             };
         }
         return new GenericResponseModel <AccountActivationModel>()
         {
             Code = string.IsNullOrEmpty(ErrorMessage) ? Utilities.Enums.CodeStatus.Success : Utilities.Enums.CodeStatus.Error,
             CodeStatus = string.IsNullOrEmpty(ErrorMessage) ? Utilities.Enums.CodeStatus.Success.ToString() : Utilities.Enums.CodeStatus.Error.ToString(),
             ReferenceObject = string.IsNullOrEmpty(ErrorMessage) ? accountActivation : null,
             ErrorMessage = string.IsNullOrEmpty(ErrorMessage) ? null : new ErrorMessage {
                 Details = ErrorDetails,
                 ErrNumber = ErrorCode,
                 Message = ErrorMessage
             }
         };
     }));
 }
示例#5
0
        public void ConfirmUser(AccountActivationModel model)
        {
            var key  = model.Email + Key;
            var hash = ComputeHash(key);

            if (hash == model.Key)
            {
                var user = Repository.GetUser(model.Email);
                if (user != null && DateTimeOffset.Now.Subtract(user.RegistrationDate).TotalHours < ConfirmationTotalHours)
                {
                    user.EmailComfirmed = true;
                    Repository.Save();
                    return;
                }
                throw new MovieUniverseException(ExceptionType.InvalidActivationKeyOrEmail);
            }
            throw new MovieUniverseException(ExceptionType.InvalidActivationKeyOrEmail);
        }
        public virtual IActionResult AccountActivation(string token, string email)
        {
            var user = _userService.GetUserByEmail(email);

            if (user == null)
            {
                return(RedirectToRoute("HomePage"));
            }

            var cToken = _genericAttributeService.GetAttribute <string>(user, NopUserDefaults.AccountActivationTokenAttribute);

            if (string.IsNullOrEmpty(cToken))
            {
                return
                    (View(new AccountActivationModel
                {
                    Result = _localizationService.GetResource("Account.AccountActivation.AlreadyActivated")
                }));
            }

            if (!cToken.Equals(token, StringComparison.InvariantCultureIgnoreCase))
            {
                return(RedirectToRoute("HomePage"));
            }

            //activate user account
            user.Active = true;
            _userService.UpdateUser(user);
            _genericAttributeService.SaveAttribute(user, NopUserDefaults.AccountActivationTokenAttribute, "");
            //send welcome message
            _workflowMessageService.SendUserWelcomeMessage(user, _workContext.WorkingLanguage.Id);

            var model = new AccountActivationModel
            {
                Result = _localizationService.GetResource("Account.AccountActivation.Activated")
            };

            return(View(model));
        }