public IActionResult Connect( [FromBody] CredentialsDTO dto, [FromQuery] bool stayConnected = false ) { ISession session = HttpContext.Session; if (!String.IsNullOrEmpty(session.GetString(SessionHandler.CREDENTIALS_KEY))) { throw new AppException("A connection is still enabled", 400); } object ret = CredentialsHandler.SetAndCheck(dto); if (stayConnected) { var cookieOptions = new CookieOptions() { IsEssential = true }; Action <string, string> addCookie = (key, value) => HttpContext.Response.Cookies.Append(key, value, cookieOptions); addCookie(USER_TYPE_KEY, $"{CredentialsHandler.GetUserType}"); addCookie(ID_KEY, $"{CredentialsHandler.GetId}"); addCookie(PASSWORD_KEY, $"{CredentialsHandler.GetPassword}"); } session.SetString(SessionHandler.CREDENTIALS_KEY, CredentialsHandler.GetString); return(Ok(ret)); }
public async Task <IHttpActionResult> Authenticate(CredentialsDTO credentials) { Fr8AccountDO account; TerminalDO terminalDO; using (var uow = ObjectFactory.GetInstance <IUnitOfWork>()) { terminalDO = _terminal.GetByNameAndVersion(credentials.Terminal.Name, credentials.Terminal.Version); account = _security.GetCurrentAccount(uow); } var response = await _authorization.AuthenticateInternal( account, terminalDO, credentials.Domain, credentials.Username, credentials.Password, credentials.IsDemoAccount ); return(Ok(new TokenResponseDTO { TerminalId = response.AuthorizationToken?.TerminalID, TerminalName = terminalDO.Name, AuthTokenId = response.AuthorizationToken?.Id.ToString(), Error = response.Error })); }
public async Task <(string token, DateTime expiration)> CreateJWT(CredentialsDTO credentials) { try { var user = await _context.Users.FirstOrDefaultAsync(c => c.Email == credentials.Email); if (user != null) { var(verified, needsUpgrade) = _pwHasher.Check(user.Password, credentials.Password); if (verified) { if (needsUpgrade) { user.Password = _pwHasher.Hash(credentials.Password); await _context.SaveChangesAsync(); } return(_tokenHelper.GenerateJWT(user.Id, user.Email)); } } return(null, DateTime.MinValue); } catch { throw; } }
public async Task <Response <AuthInfoDTO> > Authenticate(CredentialsDTO request) { var user = await _provider.GetUserDetail(request.Email); if (user.Data == null) { return(new SecurityErrorResponse <AuthInfoDTO>() { Code = ErrorCodes.Security.AuthDataInvalid, Message = ErrorMessages.Security.AuthDataInvalid, }); } if (user.Data.RoleId != RoleGuid.Admin) { return(new SecurityErrorResponse <AuthInfoDTO>() { Code = ErrorCodes.Security.AuthDataInvalid, Message = ErrorMessages.Security.AuthDataInvalid, }); } var result = await _tokensService.Authenticate(request); return(result); }
public async Task <NewsDTO> GetNews(CredentialsDTO credentials) { string text = GetContentFromEmail(credentials.EmailUsername, credentials.EmailPassword, credentials.EmailSenderFilter); NewsDTO news = GetNews(text); return(news); }
public async Task <IActionResult> Post([FromBody] CredentialsDTO credentials) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var identity = await GetClaimsIdentity(credentials.UserName, credentials.Password); if (identity == null) { return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid username or password.", ModelState))); } // Serialize and return the response var response = new { id = identity.Claims.Single(c => c.Type == "id").Value, auth_token = await _jwtFactory.GenerateEncodedToken(credentials.UserName, identity), expires_in = (int)_jwtOptions.ValidFor.TotalSeconds }; var json = JsonConvert.SerializeObject(response, _serializerSettings); return(new OkObjectResult(json)); }
public async Task <IActionResult> Validate([FromBody] CredentialsDTO account) { try { var result = await _plexAccountService.ValidatePlexAccountAsync(account.Username, account.Password); if (result.IsFailed) { string msg = $"The account failed to validate, {result}"; Log.Error(msg); return(BadRequest(result.WithError(msg))); } if (result.Value) { string msg = $"Account with username: {account.Username} was valid"; Log.Information(msg); return(Ok(Result.Ok(true).WithSuccess(msg))); } else { string msg = $"Account with username: {account.Username} was invalid"; Log.Warning(msg); return(Ok(Result.Fail(msg))); } } catch (Exception e) { return(InternalServerError(e)); } }
private void Button_sign_in_Click(object sender, EventArgs e) { CredentialsDTO credentials = new CredentialsDTO() { Login = textbox_email.Text, Password = textbox_password.Text }; if (_authenticationService.UserExist(textbox_email.Text)) { if (_authenticationService.CheckCredentials(credentials)) { MenuForm menu = DependencyInjectorBLL.Resolve <MenuForm>( new ParameterOverride("user", _userService.GetByEmail(credentials.Login))); menu.Show(); this.Hide(); } else { MessageBox.Show( "Wrong password!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } else { MessageBox.Show( "There is no such user!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public async Task <LoginResultDTO> Login(CredentialsDTO credentials) { var loginAsJson = JsonSerializer.Serialize(credentials); var response = await _httpClient.PostAsync("api/Login", new StringContent(loginAsJson, Encoding.UTF8, "application/json")); var loginResult = JsonSerializer.Deserialize <LoginResultDTO>(await response.Content.ReadAsStringAsync(), new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); if (!response.IsSuccessStatusCode || !loginResult.Successful) { return(loginResult); } await _localStorage.StoreAsync(new GlobeLocalStorageData { Token = loginResult.Token, UserName = credentials.UserName }); await((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(credentials.UserName); _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", loginResult.Token); return(loginResult); }
public async Task TestAuthenticate() { var tokenDO = CreateAndAddTokenDO(); var activityTemplateDO = new ActivityTemplateDO("test_name", "test_label", "1", "test_description", tokenDO.TerminalID); activityTemplateDO.Id = FixtureData.GetTestGuidById(1); activityTemplateDO.Terminal = ObjectFactory.GetInstance <ITerminal>().GetByKey(tokenDO.TerminalID); activityTemplateDO.Terminal.AuthenticationType = AuthenticationType.Internal; var activityDO = FixtureData.TestActivity1(); activityDO.ActivityTemplate = activityTemplateDO; // activityDO.AuthorizationToken = tokenDO; using (var uow = ObjectFactory.GetInstance <IUnitOfWork>()) { uow.PlanRepository.Add(new PlanDO() { Name = "name", PlanState = PlanState.Executing, ChildNodes = { activityDO } }); //uow.ActivityRepository.Add(activityDO); uow.ActivityTemplateRepository.Add(activityTemplateDO); uow.SaveChanges(); } var credentialsDTO = new CredentialsDTO() { Password = "******", Username = "******", Domain = "Domain", Terminal = Mapper.Map <TerminalSummaryDTO>(activityTemplateDO.Terminal) }; var result = _authenticationController.Authenticate(credentialsDTO); //Assert Mock <IRestfulServiceClient> restClientMock = Mock.Get( ObjectFactory.GetInstance <IRestfulServiceClient>() ); //verify that the post call is made restClientMock.Verify( client => client.PostAsync <CredentialsDTO>( new Uri(activityTemplateDO.Terminal.Endpoint + "/authentication/token"), It.Is <CredentialsDTO>(it => it.Username == credentialsDTO.Username && it.Password == credentialsDTO.Password && it.Domain == credentialsDTO.Domain), It.IsAny <string>(), It.IsAny <Dictionary <string, string> >() ), Times.Exactly(1) ); restClientMock.VerifyAll(); }
public ConexionOdooBuilder addUserName(string userName) { if (isNull(credentials)) { credentials = new CredentialsDTO(); } credentials.userName = userName; return(this); }
public ConexionOdooBuilder addDbName(string dbName) { if (isNull(credentials)) { credentials = new CredentialsDTO(); } credentials.dbName = dbName; return(this); }
public ConexionOdooBuilder addUrl(string url) { if (isNull(credentials)) { credentials = new CredentialsDTO(); } credentials.url = url; return(this); }
public ConexionOdooBuilder addCredentials(CredentialsDTO obj) { credentials = new CredentialsDTO { url = obj.url, dbName = obj.dbName, userName = obj.userName, password = obj.password }; return(this); }
public CredentialsDTO GetDocuSignCredentials() { var creds = new CredentialsDTO { Username = ConfigurationManager.AppSettings["TestUserEmail"], Password = ConfigurationManager.AppSettings["DocuSignApiPassword"], IsDemoAccount = true }; return(creds); }
public async Task <IActionResult> GetToken(CredentialsDTO credentials) { (string jwt, DateTime expiration) = await _authService.CreateJWT(credentials); if (string.IsNullOrWhiteSpace(jwt)) { return(BadRequest(new { message = "Username or Password is incorrect" })); } return(Ok(new { jwt, expiration })); }
public async Task <ActionResult> CreateCredential([FromBody] CredentialsDTO credentialsDTO) { try { return(Ok()); } catch (Exception e) { return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public IActionResult Post([FromBody] CredentialsDTO credentials) { if (_service.Authenticate(credentials.Login, credentials.Password)) { return(Ok()); } else { return(StatusCode(StatusCodes.Status401Unauthorized)); } }
public async Task <IActionResult> Login(CredentialsDTO credentials) { var reseller = await _resellerService.Authenticate(credentials); if (reseller != null) { var token = await _authenticationProvider.GenerateToken(Guid.NewGuid()); return(await ResponseAsync(token)); } return(Unauthorized()); }
public async Task <ApplicationUser> Login(CredentialsDTO credentials) { var user = await _userManager.FindByEmailAsync(credentials.Login); if (user == null) { return(null); } var loginResult = await _signInManager.CheckPasswordSignInAsync(user, credentials.Password, false); return(loginResult.Succeeded ? user : null); }
/// <summary> /// Authenticates user and returns jwt token. /// </summary> /// <param name="credentials"></param> /// <returns></returns> public async Task <string> Authenticate(CredentialsDTO credentials) { //Validate credentials and generate user identity ClaimsIdentity identity = null; try { identity = await GetClaimsIdentity(credentials.UserName, credentials.Password); }// rethrow exception catch (InvalidOperationException) { throw; } return(await Helpers.Tokens.GenerateJwt(identity, _jwtFactory, credentials.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented })); }
public async Task <bool> CheckAuthenticationAsync(CredentialsDTO credentials) { try { await GetAsync("configuration", credentials).ConfigureAwait(false); return(true); } catch (AuthorizationTokenExpiredOrInvalidException) { return(false); } }
public async Task <ActionResult <ResponseDTO <TokenDTO> > > getToken([FromBody] CredentialsDTO credentials) { if (credentials.UserName == null || credentials.Password == null) { return(new ResponseDTO <TokenDTO>("No credentials were given")); } if (!await AuthenticationController.CredentialsValid(credentials)) { return(new ResponseDTO <TokenDTO>("Credentials invalid")); } return(new ResponseDTO <TokenDTO>(await AuthenticationController.GenerateToken(credentials.UserName))); }
public bool CheckCredentials(CredentialsDTO credentials) { User user = _userDal.GetByLogin(credentials.Login); if (user.HashPassword == HashPassword.Hash(credentials.Password)) { return(true); } else { return(false); } }
public static AuthorizationTokenDTO Jira_AuthToken() { var curCredentialsDTO = new CredentialsDTO() { Domain = "https://maginot.atlassian.net", Username = "******", Password = "******" }; return(new AuthorizationTokenDTO() { Token = JsonConvert.SerializeObject(curCredentialsDTO) }); }
public async Task <Response <AuthInfoDTO> > Authenticate(CredentialsDTO dto) { var user = await _usersRepository.GetByEmail(dto.Email); var isPasswordValid = false; try { isPasswordValid = await ValidatePassword(dto.Password, user); } catch (Exception e) { _logger.LogError(e, e.Message); return(new SecurityErrorResponse <AuthInfoDTO>(new [] { new Error { Code = ErrorCodes.Security.AuthDataInvalid, Message = ErrorMessages.Security.AuthDataInvalid } })); } if (user == null || !isPasswordValid) { return(new SecurityErrorResponse <AuthInfoDTO>(new [] { new Error { Code = ErrorCodes.Security.AuthDataInvalid, Message = ErrorMessages.Security.AuthDataInvalid } })); } var tokenDTO = await _tokenFactory.CreateToken(user); var userDTO = _mapper.Map <UserModel, UserDTO>(user); var result = new AuthInfoDTO { User = userDTO, Token = tokenDTO }; return(new Response <AuthInfoDTO> { Data = result }); }
public async Task <IActionResult> Login(CredentialsDTO credentialsDto, [FromServices] IAuthenticationService authenticationService) { try { // Returns JWT if credentials are valid otherwise throws InvalidOperationException var jwt = await authenticationService.Authenticate(credentialsDto); return(Ok(jwt)); } catch (InvalidOperationException e) { return(BadRequest(e.Message)); } }
public async Task <IActionResult> Post([FromBody] CredentialsDTO credentials) { var user = await _identityService.Login(credentials); if (user == null) { return(Response()); } else { var responseData = BuildLoginResponse(user); return(Response(responseData)); } }
public ActionResult Login([FromBody] CredentialsDTO credentials) { User user = _BLL.Login(credentials);; if (user != null) { return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(GenerateToken(user.UserName, user.IntId)) })); } return(Unauthorized()); }
public async Task <ResellerDTO> Authenticate(CredentialsDTO credentials) { var reseller = _resellerRepository.FindBy(x => x.Email == credentials.Email); if (reseller != null) { var verified = credentials.Password.VerifyHash(reseller.Password); if (verified) { return(_mapper.Map <ResellerDTO>(reseller)); } } return(null); }