public async Task <IActionResult> CreateToken([FromBody] LoginViewModel model) { if (!ModelState.IsValid) { return(BadRequest("Invalid model")); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { return(BadRequest("User does not exist")); } var signInResult = await _signInManager.CheckPasswordSignInAsync(user, model.Password, false); if (!signInResult.Succeeded) { return(BadRequest("Invalid e-mail or password")); } var tokenKey = _config["Tokens:Key"]; var issuer = _config["Tokens:Issuer"]; var audience = _config["Tokens:Audience"]; var token = JwtTokenHelper.GenerateToken(user, tokenKey, issuer, audience); var result = new { token = new JwtSecurityTokenHandler().WriteToken(token), expiration = token.ValidTo }; return(Created(string.Empty, result)); }
public async Task GenerateClientEndpoint(string userId, Claim[] claims, string appName) { var endpoints = FakeEndpointUtils.GetFakeEndpoint(3).ToArray(); var routerMock = new Mock <IEndpointRouter>(); routerMock.SetupSequence(router => router.GetNegotiateEndpoint(null, endpoints)) .Returns(endpoints[0]) .Returns(endpoints[1]) .Returns(endpoints[2]); var router = routerMock.Object; var provider = new ServiceCollection().AddSignalRServiceManager() .Configure <ServiceManagerOptions>(o => { o.ApplicationName = appName; o.ServiceEndpoints = endpoints; }) .AddSingleton(router).BuildServiceProvider(); var negotiateProcessor = provider.GetRequiredService <NegotiateProcessor>(); for (int i = 0; i < 3; i++) { var negotiationResponse = await negotiateProcessor.NegotiateAsync(HubName, null, userId, claims, _tokenLifeTime); var tokenString = negotiationResponse.AccessToken; var token = JwtTokenHelper.JwtHandler.ReadJwtToken(tokenString); string expectedToken = JwtTokenHelper.GenerateJwtBearer(ClientEndpointUtils.GetExpectedClientEndpoint(HubName, appName, endpoints[i].Endpoint), ClaimsUtility.BuildJwtClaims(null, userId, () => claims), token.ValidTo, token.ValidFrom, token.ValidFrom, endpoints[i].AccessKey); Assert.Equal(ClientEndpointUtils.GetExpectedClientEndpoint(HubName, appName, endpoints[i].Endpoint), negotiationResponse.Url); Assert.Equal(expectedToken, tokenString); } }
public BaseResponse <bool> IsAllowedToken(string token) { try { if (string.IsNullOrEmpty(token)) { return(BaseResponse <bool> .BadRequest()); } var authModel = JwtTokenHelper.DecodeJwtToken(token); if (authModel != null) { var user = Find(authModel.Email); if (user != null) { var tokenEffectiveDate = long.Parse(authModel.TokenEffectiveTimeStick); var userEffectiveDate = user.TokenEffectiveTimeStick; if (tokenEffectiveDate > userEffectiveDate) { return(BaseResponse <bool> .Success(true)); } return(BaseResponse <bool> .BadRequest(message : "Token is not allowed because user was signed out.")); } } return(BaseResponse <bool> .BadRequest()); } catch (Exception ex) { return(BaseResponse <bool> .InternalServerError(message : ex.Message, fullMsg : ex.StackTrace)); } }
public async Task Call_NegotiateAsync_After_WithEndpoints(ServiceTransportType serviceTransportType) { var serviceManager = new ServiceManagerBuilder() .WithOptions(o => { o.ServiceTransportType = serviceTransportType; o.ServiceEndpoints = ServiceEndpoints; }) .BuildServiceManager(); var hubContext = await serviceManager.CreateHubContextAsync(Hub, default); for (var i = 0; i < 5; i++) { var randomEndpoint = ServiceEndpoints[StaticRandom.Next(0, Count)]; var negotiationResponse = await(hubContext as IInternalServiceHubContext) .WithEndpoints(new ServiceEndpoint[] { randomEndpoint }) .NegotiateAsync(); Assert.Equal(ClientEndpointUtils.GetExpectedClientEndpoint(Hub, null, randomEndpoint.Endpoint), negotiationResponse.Url); var tokenString = negotiationResponse.AccessToken; var token = JwtTokenHelper.JwtHandler.ReadJwtToken(tokenString); var expectedToken = JwtTokenHelper.GenerateJwtBearer( ClientEndpointUtils.GetExpectedClientEndpoint(Hub, null, randomEndpoint.Endpoint), ClaimsUtility.BuildJwtClaims(null, null, null), token.ValidTo, token.ValidFrom, token.ValidFrom, randomEndpoint.AccessKey); Assert.Equal(expectedToken, tokenString); } }
public async Task <BaseResponse <bool> > SingleSignInAsync(HttpContext httpContext, AuthenticateViewModel model, string authenticationScheme = "", AuthenticationProperties authenticationProperties = null) { try { if (model == null) { return(BaseResponse <bool> .BadRequest()); } authenticationScheme = (string.IsNullOrEmpty(authenticationScheme)) ? SSOAuthenticationScheme : authenticationScheme; authenticationProperties = authenticationProperties == null ? new AuthenticationProperties { IsPersistent = true, ExpiresUtc = DateTimeOffset.UtcNow.AddDays(365) } : authenticationProperties; var claims = JwtTokenHelper.GetUserClaims(model); var claimsIdentity = new ClaimsIdentity(claims, authenticationScheme); var user = new ClaimsPrincipal(claimsIdentity); await httpContext.SignInAsync(authenticationScheme, user, authenticationProperties); return(BaseResponse <bool> .Success(true)); } catch (Exception e) { return(BaseResponse <bool> .InternalServerError(message : e.Message, fullMsg : e.StackTrace)); } }
public override async Task <GrpcResponse> Login(LoginRequest request, ServerCallContext context) { var loginDto = _mapper.Map <UserLoginDto>(request); var loginResult = await _accountService.LoginAsync(loginDto); var grpcResponse = new GrpcResponse() { IsSuccessStatusCode = loginResult.IsSuccess }; if (!grpcResponse.IsSuccessStatusCode) { grpcResponse.Error = loginResult.ProblemDetails?.Detail; return(grpcResponse); } var validatedInfo = loginResult.Content; var loginReply = new LoginReply { Token = JwtTokenHelper.CreateAccessToken(_jwtOptions.Value, validatedInfo.ValidationVersion, validatedInfo.Account, validatedInfo.Id.ToString(), validatedInfo.Name, validatedInfo.RoleIds).Token, RefreshToken = JwtTokenHelper.CreateRefreshToken(_jwtOptions.Value, validatedInfo.ValidationVersion, validatedInfo.Id.ToString()).Token }; grpcResponse.Content = Any.Pack(loginReply); return(grpcResponse); }
public void BatchSendCouponsByUserEmailsAsync(IList <string> emails, CouponDto coupon) { foreach (var email in emails) { // step 1: Create payloads: user email, coupon ID IList <object> payloads = new List <object>() { "emails", coupon.Id.ToString() }; // Step 2: Generate email confirm token var token = JwtTokenHelper.GenerateToken(payloads, coupon.EndTimeUTC, _tokenConfig.Key); string tokenHtml = HttpUtility.UrlEncode(token); // Step 3: Generate email data var from = _emailConfigs.SenderGeneral; var tos = new List <string>() { email }; var ccs = new List <string>(); var subject = "Course Studio New Coupon Is Coming"; var confirmUrl = _emailConfigs.CouponRedeemUrl + "?userId=" + email + "&coupon=" + coupon.Id + "&token=" + tokenHtml; var HtmlContent = "<p>Course Studio new coupon is comingwer</p><br>" + confirmUrl; // Step 4: send email // TODO: shouldn't use the ASYNC method SendAsync(from, tos.ToArray(), ccs.ToArray(), subject, HtmlContent); } }
//For AQ Account private AuthenticateViewModel GetAuthResponseModel(Users user) { try { if (user == null) { return(null); } var authModel = _mapper.Map <Users, AuthenticateViewModel>(user); var refreshToken = UniqueIDHelper.GenarateRandomString(12); user.RefreshToken = refreshToken; var saveSucceed = _accountService.UpdateUser(user).IsSuccessStatusCode; if (saveSucceed) { authModel.RefreshToken = refreshToken; authModel.TokenEffectiveDate = DateTime.Now.ToString(); authModel.TokenEffectiveTimeStick = DateTime.Now.Ticks.ToString(); authModel.AccountTypeFid = ((int)AccountTypeEnum.Admin).ToString(); var result = JwtTokenHelper.GenerateJwtTokenModel(authModel, TOKEN_MINUTE_TIME_LIFE); return(result); } return(null); } catch { return(null); } }
public static void AddAppSetting(this IServiceCollection services, IConfiguration configuration) { DependencyInjectionHelper.Init(ref services); JwtTokenHelper.Init(configuration); services.AddOptions(); services.Configure <ApiServer>(configuration.GetSection("ApiServer")); }
public async Task <ActionResult <LoginResult> > Login([FromForm] LoginDto loginModel) { _logger.Log(LogLevel.Warning, "Received login request"); var password = EncryptHelper.DecryptWithAES(loginModel.Password); var result = await _signInManager .PasswordSignInAsync(loginModel.Username, password, loginModel.RememberMe, false); if (!result.Succeeded) { return(Unauthorized(new LoginResult { Success = false, Error = "Failed to login" })); } var user = await _userManager.FindByNameAsync(loginModel.Username); var roles = await _userManager.GetRolesAsync(user); var config = _configuration.GetSection("JwtConfig"); await _userStates.SetLoginAsync(loginModel.Username); var token = JwtTokenHelper.IssueJwtToken(user.UserName, roles.ToList(), config); _logger.LogInformation("Login successful"); return(Ok(new LoginResult { Success = true, Token = token })); }
public UsersController(IConfiguration configuration, IdeaPoolContext dbContext, JwtTokenHelper tokenHelper, ILogger <UsersController> logger) { this.configuration = configuration; this.dbContext = dbContext; this.tokenHelper = tokenHelper; this.logger = logger; }
internal void GenerateClientAccessTokenTest() { var endpoint = "https://abc"; var accessKey = "nOu3jXsHnsO5urMumc87M9skQbUWuQ+PE5IvSUEic8w="; var testConnectionString = $"Endpoint={endpoint};AccessKey={accessKey};Version=1.0;"; var userId = "UserA"; var hubName = "signalrbench"; var expectedAudience = $"{endpoint}/client/?hub={hubName.ToLower()}"; var lifeTime = TimeSpan.FromSeconds(99); var claims = new List <Claim> { new Claim(ClaimTypes.NameIdentifier, userId), new Claim("type1", "val1") }; var serviceManagerOptions = new ServiceManagerOptions { ConnectionString = testConnectionString, ServiceTransportType = ServiceTransportType.Transient }; var serviceManager = new ServiceManager(serviceManagerOptions); var tokenString = serviceManager.GenerateClientAccessToken(hubName, claims, lifeTime); var token = JwtTokenHelper.JwtHandler.ReadJwtToken(tokenString); var customClaims = new Claim[] { new Claim("type1", "val1") }; string expectedToken = JwtTokenHelper.GenerateExpectedAccessToken(token, expectedAudience, accessKey, customClaims); Assert.Equal(expectedToken, tokenString); }
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { HttpStatusCode statusCode; string token; //determine whether a jwt exists or not if (!TryRetrieveToken(request, out token)) { statusCode = HttpStatusCode.Unauthorized; //allow requests with no token - whether a action method needs an authentication can be set with the claimsauthorization attribute return(base.SendAsync(request, cancellationToken)); } try { SecurityToken securityToken; JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler(); var validationParameters = JwtTokenHelper.GetTokenValidationParameters(Settings.JwtSecretKey); //extract and assign the user of the jwt Thread.CurrentPrincipal = handler.ValidateToken(token, validationParameters, out securityToken); HttpContext.Current.User = handler.ValidateToken(token, validationParameters, out securityToken); return(base.SendAsync(request, cancellationToken)); } catch (SecurityTokenValidationException) { statusCode = HttpStatusCode.Unauthorized; } catch (Exception) { statusCode = HttpStatusCode.InternalServerError; } return(Task <HttpResponseMessage> .Factory.StartNew(() => new HttpResponseMessage(statusCode) { })); }
public async Task <IActionResult> Login(LoginModel loginModel) { _logger.LogInformation("Started : Logging In."); UserDto userDto = await _userService.AuthenticateUser(loginModel.UserName, loginModel.Password); if (userDto != null) { // On Successful authentication, generate jwt token. string token = JwtTokenHelper.GenerateJwtToken(userDto, _appSettings); return(Ok( new ApiResponse <string> { IsSuccess = true, Result = token, Message = "Authentication successful." })); } else { return(BadRequest( new ApiResponse <string> { IsSuccess = false, Result = "Authentication failed.", Message = "Username or password is incorrect." })); } }
public IActionResult Create([FromBody] UserCreateModel createModel) { var userId = JwtTokenHelper.GetSignInProfile(User).UserId; var result = _accountService.Resigster(createModel, userId); return(Ok(result)); }
public IHttpActionResult PostPaRequestNotes(PaRequestNote paRequestNote) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var headers = Request.Headers; if (headers.Contains("token")) { var userToken = headers.GetValues("token").First(); string userName = JwtTokenHelper.GetTokenPayloadValue(userToken, "unique_name"); paRequestNote.Created = DateTime.Now; paRequestNote.CreatedBy = userName; paRequestNote.LastModified = DateTime.Now; paRequestNote.LastModifiedBy = userName; db.PaRequestNotes.Add(paRequestNote); db.SaveChanges(); } return(CreatedAtRoute("DefaultApi", new { id = paRequestNote.Id }, paRequestNote)); }
/// <summary> /// Initializes a new instance of the <see cref="AsyncInitializationMiddleware"/> class. /// </summary> /// <param name="next">The next middleware.</param> /// <param name="jwtTokenHelper">The JWT token helper.</param> /// <param name="awsCognitoClientSecretHelper">The AWS Cognito Client Secret Helper.</param> /// <param name="lifetime">The application lifetime.</param> /// <param name="awsCognitoHelper">The AWS Cognito Helper.</param> /// <param name="configSettings">The Config Settings.</param> /// <param name="logger">Logger</param> public AsyncInitializationMiddleware(RequestDelegate next, IHostApplicationLifetime lifetime, AWSCognitoHelper awsCognitoHelper, JwtTokenHelper jwtTokenHelper, AWSCognitoClientSecretHelper awsCognitoClientSecretHelper, IOptions <ConfigSettings> configSettings, ILogger <AsyncInitializationMiddleware> logger ) { this._next = next; this._awsCognitoHelper = awsCognitoHelper; this._awsCognitoClientSecretHelper = awsCognitoClientSecretHelper; this._configSettings = configSettings.Value; this._jwtTokenHelper = jwtTokenHelper; this._logger = logger; // Start initialization when the app starts var startRegistration = default(CancellationTokenRegistration); var registration = startRegistration; lifetime.ApplicationStarted.Register(() => { _initializationTask = InitializeAsync(lifetime.ApplicationStopping); registration.Dispose(); }); }
public ActionResult <object> Get(string username, string password) { Managers managerModel = _manager.Login(username, password); var jwtSection = _configuration.GetSection("jwt"); int tokenExpires = Convert.ToInt32(jwtSection.GetSection("TokenExpires").Value); int refreshTokenExpires = Convert.ToInt32(jwtSection.GetSection("RefreshTokenExpires").Value); if (managerModel == null) { return(ErrorResult <int>("用户名或密码错误")); } JwtTokenHelper jwtTokenHelper = new JwtTokenHelper(); var claims = new Claim[] { new Claim(ClaimTypes.Name, managerModel.UserName), new Claim(ClaimTypes.Role, managerModel.RoleId.ToString()), new Claim(JwtRegisteredClaimNames.Sid, managerModel.Id.ToString()), }; string token = jwtTokenHelper.GetToken(claims); string refreshToken = jwtTokenHelper.RefreshToken(); string tokenExpired = StringHelper.GetTimeStamp(DateTime.UtcNow.AddMinutes(tokenExpires)); string refreshToeknExpired = StringHelper.GetTimeStamp(DateTime.UtcNow.AddMinutes(refreshTokenExpires)); _manager.AddRefeshToken(token, refreshToken, managerModel.Id, refreshTokenExpires); return(SuccessResult <object>(new { token = token, refreshToken = refreshToken, userName = managerModel.UserName, expires = tokenExpired, refreshExpires = refreshToeknExpired })); }
private string RefreshToken(UserLogin userAccount, User userDetails) { var refreshId = DateTime.Now.Ticks; // To verify freshness of issued Token. JwtPayload payload = new JwtPayload(); payload.Add("isAdmin", userAccount.IsAdmin); payload.Add("userLoginId", userAccount.Id); payload.Add("displayName", userDetails.FirstName + " " + userDetails.LastName); payload.Add("refreshId", refreshId); var token = JwtTokenHelper.GenerateJwtToken(userAccount.Login, userDetails.Role.Name, payload); userAccount.AccessFailedCount = 0; userAccount.LockoutEnabled = false; userAccount.LockoutEnd = DateTime.Parse("1/1/1900"); userAccount.RefreshId = refreshId; userAccount.LastModifiedBy = "SECURITY"; userAccount.LastModified = DateTime.Now; db.Entry(userAccount).State = EntityState.Modified; try { db.SaveChanges(); } catch (Exception e) { Console.WriteLine(e); throw; } return(token); }
public void GenerateJwtToken_Should_Return_Null_With_Missing_Or_Empty_JwtSettings_Info(IJwtSettings settings) { JwtTokenHelper helper = new JwtTokenHelper(settings); var token = helper.GenerateJwtToken(sampleUser); Assert.Null(token); }
protected async Task <IActionResult> GenerateJWTToken(TUser user) { var rolesAndScopes = await AuthenticationHelper.GetRolesAndScopesAsync(user, _userManager, _roleManager); var roles = rolesAndScopes.Roles; var scopes = rolesAndScopes.Scopes; if (!string.IsNullOrWhiteSpace(_privateSigningKeyPath)) { var key = SigningKey.LoadPrivateRsaSigningKey(_privateSigningKeyPath); var results = JwtTokenHelper.CreateJwtTokenSigningWithRsaSecurityKey(user.Id, user.UserName, user.Email, roles, _tokenExpiryMinutes, key, _localIssuer, _audience, scopes.ToArray()); return(Created("", results)); } else if (!string.IsNullOrWhiteSpace(_privateSigningCertificatePassword)) { var key = SigningKey.LoadPrivateSigningCertificate(_privateSigningCertificatePath, _privateSigningCertificatePassword); var results = JwtTokenHelper.CreateJwtTokenSigningWithCertificateSecurityKey(user.Id, user.UserName, user.Email, roles, _tokenExpiryMinutes, key, _localIssuer, _audience, scopes.ToArray()); return(Created("", results)); } else { var key = SigningKey.LoadSymmetricSecurityKey(_privateSymmetricKey); var results = JwtTokenHelper.CreateJwtTokenSigningWithKey(user.Id, user.UserName, user.Email, roles, _tokenExpiryMinutes, key, _localIssuer, _audience, scopes.ToArray()); return(Created("", results)); } }
public void GenerateJwtToken_Should_Return_Not_Null_Token() { JwtTokenHelper helper = new JwtTokenHelper(new JwtSettingsFake()); var token = helper.GenerateJwtToken(sampleUser); Assert.NotNull(token); }
public override void OnActionExecuted(ActionExecutedContext actionExecutedContext) { if (this._userContext.TokenExpiry != null) { DateTime tokenExpiresOn = Convert.ToDateTime(this._userContext.TokenExpiry); if (DateTime.Now.AddMinutes(15) > tokenExpiresOn) { // Generate new token try { if (string.IsNullOrEmpty(actionExecutedContext.HttpContext.Response.Headers["RefreshToken"])) { var token = JwtTokenHelper.GenerateJSONWebToken( this._jwtIssuerOptions, this._userContext.UserInfo.Id, this._userContext.UserInfo.Email, this._userContext.SessionId); actionExecutedContext.HttpContext.Response.Headers.Add("RefreshToken", token); } } catch (Exception) { // throw; } } } }
public void GenerateJwtToken_Should_Return_Token_With_Correct_Info() { var jwtSettings = new JwtSettingsFake(); var helper = new JwtTokenHelper(jwtSettings); var token = helper.GenerateJwtToken(sampleUser); var tokenHandler = new JwtSecurityTokenHandler(); var tokenValidationParams = new TokenValidationParameters() { ValidateIssuer = true, ValidateAudience = true, ValidateLifetime = true, ValidateIssuerSigningKey = true, ValidIssuer = jwtSettings.Issuer, ValidAudience = jwtSettings.Issuer, IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSettings.TokenSecret)) }; SecurityToken validatedToken; var claims = tokenHandler.ValidateToken(token, tokenValidationParams, out validatedToken); Assert.True(claims.Identity.IsAuthenticated); }
/// <summary> /// Method for Host Login Access /// </summary> /// <param name="email"></param> /// <param name="password"></param> /// <returns></returns> public async Task <bool> HostLoginAccess(string email, string password) { //checking null Object if (email == null && password == null) { throw new NullReferenceException("host"); } //checking null fields if (email == null || password == null) { throw new UserDoesNotExistException("Email or password cannot be null"); } string hashedPassword = await _repositoryUtility.IsValidHostLogin(email); if (hashedPassword == null) { throw new UserDoesNotExistException("Email not registered for host"); } bool isSame = _userUtilityHelper.CheckPassword(password, hashedPassword); if (isSame == true) { //code to generate access token JwtTokenHelper tokenobj = new JwtTokenHelper(); string tokenString = tokenobj.GenerateToken(email, "host"); } return(await Task.FromResult(isSame)); }
public IActionResult SignOutAllDevices() { var key = JwtTokenHelper.GetClaimValue(User, ClaimConstant.Email) ?? string.Empty; var result = _signInService.SignOutAllDevice(key); return(Ok(result)); }
public BaseResponse <string> Create(string token, string returnUrl) { try { if (string.IsNullOrEmpty(token) || JwtTokenHelper.DecodeJwtToken(token) == null) { return(BaseResponse <string> .BadRequest()); } var authModel = JwtTokenHelper.DecodeJwtToken(token); var userToken = new UserTokens() { Id = UniqueIDHelper.GenarateRandomString(12), UserFid = Guid.Parse(authModel.UserId), AccessToken = token, ReturnUrl = returnUrl, }; _db.UserTokens.Add(userToken); if (_db.SaveChanges() > 0) { return(BaseResponse <string> .Success(userToken.Id)); } return(BaseResponse <string> .BadRequest()); } catch (Exception ex) { return(BaseResponse <string> .InternalServerError(message : ex.Message, fullMsg : ex.StackTrace)); } }
public async Task <ActionResult <UserTokenInfoDto> > RefreshAccessTokenAsync([FromBody] UserRefreshTokenDto input) { var claimOfId = JwtTokenHelper.GetClaimFromRefeshToken(_jwtOptions.Value, input.RefreshToken, JwtRegisteredClaimNames.NameId); if (claimOfId is not null) { var id = claimOfId.Value.ToLong(); if (id is null) { return(Forbid()); } var validatedInfo = await _accountService.GetUserValidatedInfoAsync(id.Value); if (validatedInfo is null) { return(Forbid()); } var jti = JwtTokenHelper.GetClaimFromRefeshToken(_jwtOptions.Value, input.RefreshToken, JwtRegisteredClaimNames.Jti); if (jti.Value != validatedInfo.ValidationVersion) { return(Forbid()); } var accessToken = JwtTokenHelper.CreateAccessToken(_jwtOptions.Value, validatedInfo.ValidationVersion, validatedInfo.Account, validatedInfo.Id.ToString(), validatedInfo.Name, validatedInfo.RoleIds); var refreshToken = JwtTokenHelper.CreateRefreshToken(_jwtOptions.Value, validatedInfo.ValidationVersion, validatedInfo.Id.ToString()); await _accountService.ChangeUserValidateInfoExpiresDtAsync(id.Value); var tokenInfo = new UserTokenInfoDto(accessToken.Token, accessToken.Expire, refreshToken.Token, refreshToken.Expire); return(Ok(tokenInfo)); } return(Forbid()); }
public LoginResponse Login([FromBody] LoginRequest login) { if (login == null) { throw new ArgumentNullException(nameof(login)); } connectionFactory = ConnectionHelper.GetConnection(); var context = new DbContext(connectionFactory); var userRep = new UserRepository(context); var user = userRep.LoginUser(login.Username, login.Password); // if credentials are valid if (user != null) { string token = JwtTokenHelper.GenerateToken(user.UserId.ToString(), user.UserName, user.FirstName, user.LastName); //return the token return(new LoginResponse { Token = token }); } else { throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Incorrect Username or Password.")); } }
public BaseResponse <AuthenticateViewModel> AuthenticateByToken(string accessToken) { try { if (string.IsNullOrEmpty(accessToken)) { return(BaseResponse <AuthenticateViewModel> .BadRequest()); } var authModel = JwtTokenHelper.DecodeJwtToken(accessToken); if (authModel != null && !string.IsNullOrEmpty(authModel.Email)) { var user = LoadRelated(FindByEmail(authModel.Email)); if (user == null) { return(BaseResponse <AuthenticateViewModel> .NotFound()); } if (IsNotDeleted(user) && IsActivated(user)) { var authResponseModel = GetAuthResponseModel(user); if (authResponseModel != null) { return(BaseResponse <AuthenticateViewModel> .Success(authResponseModel)); } } } return(BaseResponse <AuthenticateViewModel> .BadRequest()); } catch (Exception ex) { return(BaseResponse <AuthenticateViewModel> .InternalServerError(message : ex.Message, fullMsg : ex.StackTrace)); } }