public ActionResult <User> Register([FromBody, Required] CliendId client) { if (client == null) { return(BadRequest("Missing clientId")); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var userName = _userNameGenerator.Generate(); var token = _tokenGenerator.Generate(userName, client); var user = new User { Name = userName, ConnectionId = client.ConnectionId, Token = token }; _userService.Register(user); return(Created("", user)); } catch (InvalidOperationException) { return(Problem("No username available")); } }
public ActionResult Signup(string Email) { NewsletterSignup signup = repo.GetFirst <NewsletterSignup>(ns => ns.Email == Email); if (signup == null) { signup = new NewsletterSignup() { Email = Email, VerificationToken = tokenGenerator.Generate(16), Verified = false }; repo.Create <NewsletterSignup>(signup); } else { signup.VerificationToken = tokenGenerator.Generate(16); repo.Update <NewsletterSignup>(signup); } repo.Save(); MailMessage mail = new MailMessage(); mail.To.Add(new MailAddress(Email)); var link = new Uri(HttpContext.Request.Url, Url.Action("Verify", new { token = signup.VerificationToken })); mail.Body = String.Format("Welkom bij de CinemaTicketSystem nieuwsbrief,<br><a href=\"{0}\">Valideer je e-mailadres.</a>", link); mail.IsBodyHtml = true; mailer.Send(mail); return(View(signup)); }
private void UpdateChangeToken(EntityEntry <TDbEntity> entry, TEntity entity) { if (_modelProperties.HasConcurrencyToken) { PropertyEntry <TDbEntity, string> concurrencyToken = entry.Property <string>(_modelProperties.ConcurrencyTokenPropertyName); if (entity is IHasChangeTokenEx expectedChangeToken) { concurrencyToken.OriginalValue = expectedChangeToken.ExpectedChangeToken; if (entry.State != EntityState.Deleted) { string changeToken = expectedChangeToken.ChangeToken; if (string.IsNullOrWhiteSpace(changeToken) || string.Equals(changeToken, expectedChangeToken.ExpectedChangeToken)) { changeToken = _tokenGenerator.Generate(); } concurrencyToken.CurrentValue = changeToken; } } else if (entity is IHasChangeToken changeToken) { concurrencyToken.OriginalValue = changeToken.ChangeToken; if (entry.State != EntityState.Deleted) { concurrencyToken.CurrentValue = _tokenGenerator.Generate(); } } } }
public async Task <IActionResult> Login([FromBody] LoginDto loginDto) { var user = await _unitOfWork.UserService.Login(loginDto); if (!user.Success) { return(user.ApiResult); } //if token of user Is Already valid and exist in token pol use that token var userToken = await _unitOfWork.UserTokenService.GetUserTokenAsync(user.Data.Id); if (userToken != null && userToken.ExpiredDate > DateTime.Now) { return(Ok(new TokenDto { AccessToken = userToken.Token })); } var authToken = await _tokenGenerator.Generate(user.Data); if (!authToken.Success) { return(authToken.ApiResult); } return(Ok(new TokenDto { AccessToken = authToken.Data.AccessToken })); }
public TokenGeneratorTests() { _appSettings = new AppSettings { Secret = "STRINGU ALA BLANAOSSTRINGU ALA BLANAOS BLANAOSSTRINGU ALA BLANAOS BLANAOSSTRINGU ALA BLANAOS BLANAOSSTRINGU ALA BLANAOS", TokenLifetimeDays = 7 }; _tokenGenerator = new TokenGenerator(); User = new UserTokenDataModel { Id = 1, DisplayName = "testttt", Email = "*****@*****.**", UserRole = UserRole.Admin.ToString() }; Token = _tokenGenerator.Generate(_appSettings, User); Key = Encoding.ASCII.GetBytes(_appSettings.Secret); Validations = new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = new SymmetricSecurityKey(Key), ValidateIssuer = false, ValidateAudience = false }; Handler = new JwtSecurityTokenHandler(); }
public async Task <UserLoginResponseViewModel> Authenticate(string email, string password) { var user = await _mediator.Send(new GetUserByEmailAndPasswordQuery { Email = email, Password = password }); if (user == null) { return(null); } if (user.IsEnabled == false) { return(null); } var userData = new UserTokenDataModel { Id = user.Id, Email = email, DisplayName = user.DisplayName, UserRole = user.UserRole }; var token = _tokenGenerator.Generate(_appSettings, userData); return(new UserLoginResponseViewModel { Token = token, Email = user.Email, DisplayName = user.DisplayName, UserRole = user.UserRole }); }
public async Task <Result <TokenDto> > Handle(ConfirmCodeCommand request, CancellationToken cancellationToken) { var user = await _userRepository.GetAsync(x => x.Mobile == request.Mobile && x.ActiveCode == request.Code, cancellationToken); if (user is null) { return(Result <TokenDto> .Failed(new BadRequestObjectResult(new ApiMessage(ResponseMessage.InvalidConfirmCode)))); } if (user.ExpiredCode < DateTime.Now) { return(Result <TokenDto> .Failed(new BadRequestObjectResult(new ApiMessage(ResponseMessage.ExpiredCode)))); } user.IsMobileConfirm = true; await _userRepository.UpdateAsync(user); var result = await _tokenGenerator.Generate(user, cancellationToken); return(Result <TokenDto> .SuccessFul(new TokenDto { AccessToken = result.Data.AccessToken })); }
public ActionResult <IEnumerable <string> > Login([FromForm] LoginRequestModel requestModel) { var user = _unitOfWork.Users.FindByLogin(requestModel.Login); if (_passwordHasher.Verify(requestModel.Password, user)) { user.AccessToken = _tokenGenerator.Generate(); _unitOfWork.Users.Update(user); _unitOfWork.Commit(); return(Ok(new { user.AccessToken })); } return(Unauthorized(new { Message = "Please provider correct credentials" })); }
public void Execute(AddNewProject command) { _projectRepository.Add(new Project() { Name = command.Name, Url = command.Url, Description = command.Description, Token = _tokenGenerator.Generate(command.Name) }); }
public ActionResult Index(string identity) { if (identity == null) { return(null); } var token = _tokenGenerator.Generate(identity); return(Json(new { identity, token })); }
public IActionResult GetToken([FromBody] JObject data) { GetToken getToken = data["GetToken"].ToObject <GetToken>(); if (getToken.device == null || getToken.TenGuid == null) { return(null); } var token = _tokenGenerator.Generate(getToken.TenGuid, getToken.device); return(Ok(token)); }
public ActionResult Index(string device, string identity) { if (device == null || identity == null) { return(null); } const string appName = "TwilioChatDemo"; var endpointId = string.Format("{0}:{1}:{2}", appName, identity, device); var token = _tokenGenerator.Generate(identity, endpointId); return(Json(new { identity, token })); }
private async Task <TokenCreateResponse> InternalCreateAsync(TokenCreateRequest tokenCreateRequest, CancellationToken cancellationToken = default(CancellationToken)) { //TODO business rule: should we receive a deviceId to "connect" the token with that device? var generatedToken = _tokenGenerator.Generate(new Card(tokenCreateRequest.CardNumber, tokenCreateRequest.Cvv), _tokenGeneratorClock.Now()); var tokenRegistration = new TokenRegistration(generatedToken.Value, tokenCreateRequest.CardNumber, generatedToken.GeneratedAt); _databaseContext.TokenRegistrations.Add(tokenRegistration); await _databaseContext.SaveChangesAsync(cancellationToken); return(new TokenCreateResponse(generatedToken.GeneratedAt, generatedToken.Value)); }
public void TokenGenerator_GeneratedValidToken() { // Act var token = _tokenGenerator.Generate(); // Assert Assert.IsNotNull(token); Assert.IsNotEmpty(token); Assert.IsFalse(token.Contains("/")); Assert.IsFalse(token.Contains("+")); Assert.IsFalse(token.EndsWith("=")); }
public IActionResult GetToken([FromBody] JObject data) { GetToken getToken = data["GetToken"].ToObject <GetToken>(); if (getToken.device == null || getToken.LoggedInUserAuth0ID == null) { return(null); } var token = _tokenGenerator.Generate(getToken.LoggedInUserAuth0ID, getToken.channelName, getToken.device, getToken.TokenType); return(Ok(token)); }
public void Process_TokenGenerated_SavedLoginToken_EmailSent_Success() { // Arrange _tokenGenerator.Generate().Returns(Token); // Act _loginProcessor.Process(UserId); // Assert AssertIfTokenGenerated(); AssertIfLoginTokenSaved(); AssertIfConfirmationEmailWasSent(); }
public UserSession Create(User executor) { var userSession = new UserSession { Id = _tokenGenerator.Generate(), User = executor, Expires = _tokenExpirationProvider.GetExpiration(_timeProvider.Now()) }; _writeableRepository.Create(userSession); return(userSession); }
public async Task <string> GetToken(string identity) { if (identity == null) { identity = randomUserId(); } var token = await _tokenGenerator .Generate(identity) .ConfigureAwait(false); return(token); }
public HttpResponseMessage Create(Token tok) { if (tok.device == null || tok.identity == null) { return(null); } const string appName = "TwilioChatDemo"; var endpointId = string.Format("{0}:{1}:{2}", appName, tok.identity, tok.device); var token = _tokenGenerator.Generate(tok.identity, endpointId); return(ConvertToJSON(new { tok.identity, token })); }
public ActionResult <string> Register([FromBody] RegistrationRequest registrationRequest) { if (_userRepository.Save( new User { Name = registrationRequest.Name, Email = registrationRequest.Email, PasswordHash = registrationRequest.PasswordHash }) == true) { return(Ok(_tokenGenerator.Generate(registrationRequest))); } return(BadRequest()); }
private void SaveRegistrationConfirmation(int userId, LoginType type, out string token) { token = _tokenGenerator.Generate(); var registration = new UserAccountDto { ConfirmationToken = token, ConfirmationExpirationDate = _expirationTokenDateTime, UserId = userId, LoginType = (byte)type }; _logger.Debug($"registration data: {registration}"); _accountRepository.Save(registration); }
private void UserRegistration_Register_MemberCreated_PasswordSaved_ConfirmationEmailSent(UserToRegister user) { ReturnDefaultMemberType(); IMember registeredUser = GetRegisteredMember(user); _tokenGenerator.Generate().Returns(GeneratedToken); _memberService.CreateMemberWithIdentity(user.Username, user.Email, user.Name, DefaultMemberTypeAlias).Returns(registeredUser); // Act _userRegistration.Register(user); // Assert AssertIfMemberWasCreated(user, registeredUser, shouldBeApproved: user.Type == UserType.ValtechUk); AsserrIfConfirmationDataWasSaved(); AssertIfConfirmationEmailWasSent(user.Email); }
public async Task <JsonResult> GetToken(string identity) { if (identity == null) { identity = randomUserId(); } var endpoint = $"TwilioChatDemo:{identity}:browser"; var token = await _tokenGenerator .Generate(identity, endpoint) .ConfigureAwait(false); return(Json(new { identity, token })); }
public async Task <LoginResponseDto> Handle(LoginCommand request, CancellationToken cancellationToken) { var entity = await _context.Users.SingleOrDefaultAsync(u => u.IsActive && u.Email == request.Email && u.Password == request.Password); if (entity == null) { throw new NotFoundException(); //should have a custom message here to send proper http status to client } var result = new LoginResponseDto() { Id = entity.Id, Name = entity.Name, Token = _generator.Generate(entity) }; return(result); }
public async Task <CreateProfileResponse> Handle(CreateProfileCommand request, CancellationToken cancellationToken) { var existingProfile = await repository.GetProfileAsync(request.DeviceId, cancellationToken); if (existingProfile != null) { if (existingProfile.PushToken != request.PushToken) { existingProfile.UpdatePushToken(request.PushToken); } await repository.UnitOfWork.SaveChangesAsync(cancellationToken); return(new CreateProfileResponse { ProfileId = existingProfile.Id, DeviceId = existingProfile.DeviceId }); } string token = tokenGenerator.Generate(); var profile = new Profile(request.DeviceId, request.PushToken, request.Locale, token); var os = request.AppOperationSystem switch { "anr" => Platform.Android, "ios" => Platform.Ios, _ => Platform.Undefined }; profile.AddClientInfo(new ClientInfo(request.AppName, request.AppIntegrator, request.AppVersion, os)); await repository.CreateProfileAsync(profile, cancellationToken); await repository.UnitOfWork.SaveChangesAsync(cancellationToken); profile.ChangeMedicalId(hashGenerator.Generate(profile.Id)); await repository.UnitOfWork.SaveChangesAsync(cancellationToken); return(new CreateProfileResponse { ProfileId = profile.Id, DeviceId = profile.DeviceId }); } }
public async Task <Result <TokenDto> > Handle(Command.LoginCommand.LoginCommand request, CancellationToken cancellationToken) { var user = await _userRepository.GetAsync(x => x.Mobile == request.Mobile && x.IsDelete == false, cancellationToken); if (user is null) { return(Result <TokenDto> .Failed(new BadRequestObjectResult(new ApiMessage(ResponseMessage.InvalidUserNameOrPassword)))); } if (PasswordManagement.CheckPassword(request.Password, user.Password) == false) { return(Result <TokenDto> .Failed(new BadRequestObjectResult(new ApiMessage(ResponseMessage.InvalidUserNameOrPassword)))); } if (user.IsMobileConfirm == false) { return(Result <TokenDto> .Failed(new BadRequestObjectResult(new ApiMessage(ResponseMessage.AccountDeactivate)))); } var userToken = await _userTokenRepository.GetAsync(x => x.IsExpired == false && x.ExpiredDate >= DateTime.Now && x.UserId == user.Id, cancellationToken); //if user already have valid token in database if (userToken != null) { return(Result <TokenDto> .SuccessFul(new TokenDto { AccessToken = userToken.Token, RoleName = user.Roles.FirstOrDefault()?.Name })); } var result = await _tokenGenerator.Generate(user, cancellationToken); return(Result <TokenDto> .SuccessFul(new TokenDto { AccessToken = result.Data.AccessToken, RoleName = result.Data.RoleName })); }
public async Task <IActionResult> CreateToken([FromBody] TokenCreateRequestDto tokenCreateRequestDto) { if (tokenCreateRequestDto == null) { return(BadRequest(ErrorDto.FromMessage(ErrorMessages.EmptyDtoReceived))); } var(username, password) = tokenCreateRequestDto; var user = await _userService.GetUser(username, password); if (user == null) { return(BadRequest(ErrorDto.FromMessage(ErrorMessages.InvalidCredentials))); } var tokens = _tokenGenerator.Generate(user); var tokenDto = new TokenDto(user, tokens); return(Ok(tokenDto)); }
public async Task <CreateProfileResponse> Handle(CreateProfileCommand request, CancellationToken cancellationToken) { var existingProfile = await repository.GetProfileAsync(request.DeviceId, cancellationToken); if (existingProfile != null) { if (existingProfile.PushToken != request.PushToken) { existingProfile.UpdatePushToken(request.PushToken); } if (existingProfile.PhoneNumber != request.PhoneNumber) { existingProfile.UpdatePhoneNumber(request.PhoneNumber); } await repository.UnitOfWork.SaveChangesAsync(cancellationToken); return(new CreateProfileResponse { ProfileId = existingProfile.Id, DeviceId = existingProfile.DeviceId }); } uint nextId = idGenerator.Generate("profile"); string token = tokenGenerator.Generate(); var profile = new Profile(nextId, request.DeviceId, request.PushToken, request.Locale, token, request.PhoneNumber); await repository.CreateProfileAsync(profile, cancellationToken); await repository.UnitOfWork.SaveChangesAsync(cancellationToken); profile.ChangeMedicalId(hashGenerator.Generate(profile.Id)); await repository.UnitOfWork.SaveChangesAsync(cancellationToken); return(new CreateProfileResponse { ProfileId = profile.Id, DeviceId = profile.DeviceId }); }
public async Task <ActionResult <LoginResponse> > ValidateUser(LoginRequest loginRequest) { try { UserProfileEntity userEntity = Mapper.Map <UserProfileEntity>(loginRequest); var validUser = await _userProfileService.AuthenticateAsync(userEntity); var tokenString = _tokenGenerator.Generate(validUser); var result = Mapper.Map <LoginResponse>(validUser); var resultWithToken = result with { Token = tokenString, IsAuthenticated = true, LoginTime = DateTime.UtcNow }; return(Ok(resultWithToken)); } catch (InvalidPasswordOrUsernameException) { return(BadRequest("Invalid Password or Username")); } }
public string GenerateToken(string name, string password) { string tokenValue = tokenRepository.GetTokenByName(name).Value; if (!string.IsNullOrEmpty(tokenValue)) { return(tokenValue); } if (identityRepository.Exist(name, password)) { var token = new Token( identityRepository.Get(name).Id, tokenGenerator.Generate(), TimeProvider.Current.Now, GetExpiredTime()); tokenRepository.Add(token); return(token.Value); } return(String.Empty); }