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);
}
