public async Task <AuthenResponseModel> GetAccessToken(LoginViewModel model) { try { var loginAsJson = JsonSerializer.Serialize(model); var response = await _httpClient.PostAsync($"api/{_apiOptions.Version}/Token/Login", new StringContent(loginAsJson, Encoding.UTF8, "application/json")); var loginResult = JsonSerializer.Deserialize <AuthenResponseModel>(await response.Content.ReadAsStringAsync(), new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); if (!response.IsSuccessStatusCode) { loginResult.Successful = false; return(loginResult); } await _localStorage.SetItemAsync("authToken", loginResult.AuthenToken); ((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(loginResult.Email); _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", loginResult.AuthenToken); loginResult.Successful = true; return(loginResult); } catch (Exception ex) { _logger.LogError(ex.Message); return(new AuthenResponseModel() { Successful = false }); } }
public async Task <bool> Login(LoginModel user) { var response = await _client.PostAsJsonAsync(Endpoints.LoginEndpoint, user); if (!response.IsSuccessStatusCode) { return(false); } var content = await response.Content.ReadAsStringAsync(); var token = JsonConvert.DeserializeObject <TokenResponse>(content); //store the token await _localStorage.SetItemAsync("authToken", token.Token); //change the authorization state of the application //we need to call this to do the login await((APIAuthenticationStateProvider)_authenticationStateProvider).LogginIn(); //setting the default request header, this is not necessary because we are already adding this to the call everytime _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", token.Token); return(true); }
public async Task SetCurrentCultureAsync(string cultureCode) { var culture = new CultureInfo(cultureCode); SetCurrentCultureForApplication(culture); await _localStorageService.SetItemAsync(LocalStorageKeys.CURRENT_CULTURE, cultureCode); }
public async Task <bool> Login(LoginModel user) { var request = new HttpRequestMessage(HttpMethod.Post, Endpoints.LoginEndpoint) { Content = new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json") }; var client = _client.CreateClient(); HttpResponseMessage response = await client.SendAsync(request); if (!response.IsSuccessStatusCode) { return(false); } var content = await response.Content.ReadAsStringAsync(); var token = JsonConvert.DeserializeObject <TokenResponse>(content); //Store Token await _localStorage.SetItemAsync("authToken", token.Token); //Change auth state of app await((ApiAuthenticationStateProvider)_authenticationStateProvider).LoggedIn(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", token.Token); return(true); }
public async Task <ProjectsMetadataContainer?> Migrate(ProjectsMetadataContainer?container) { if (container?.Version == 1 && container.Item?.Count > 1) { List <int> checkedIds = new(); List <ProjectMetadata> itemsToRemove = new(); foreach (var item in container.Item) { if (!checkedIds.Contains(item.Id)) { checkedIds.Add(item.Id); } else { itemsToRemove.Add(item); } } foreach (var itemToRemove in itemsToRemove) { container.Item.Remove(itemToRemove); } container.Version = 2; } if (container != null) { await _localStorage.SetItemAsync(container.StorageTableName, container); } return(container); }
public async Task <AuthenticatedUserModel> Login(AuthenticationUserModel authenticationUserModel) { var data = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("grant_type", "password"), new KeyValuePair <string, string>("username", authenticationUserModel.Email), new KeyValuePair <string, string>("password", authenticationUserModel.Password), }); string api = _configuration["apiLocation"] + _configuration["tokenEndpoint"]; var authResult = await _httpClient.PostAsync(api, data); var authContent = await authResult.Content.ReadAsStringAsync(); if (authResult.IsSuccessStatusCode == false) { return(null); } var result = JsonSerializer.Deserialize <AuthenticatedUserModel>(authContent, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); await _localStorageService.SetItemAsync(authTokenStorageKey, result.Access_Token); ((AuthStateProvider)_authenticationStateProvider).NotifyUserAuthentication(result.Access_Token); _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", result.Access_Token); return(result); }
public async Task <bool> Login(LoginModel user) { var response = await _client.PostAsJsonAsync(Endpoints.LoginrUrl, user); if (response.IsSuccessStatusCode == false) { return(false); } // get the Token from the response var content = await response.Content.ReadAsStringAsync(); var token = JsonConvert.DeserializeObject <TokenResponse>(content); // Store token await _localStorage.SetItemAsync("authToken", token.Token); // Change State of the app await _authStateProvider.LoggedIn(); _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", token.Token); return(true); }
public async Task <bool?> SignInAsync(string email, string password) { var response = await _userService.SignInAsync(new SignInRequest { Email = email, Password = password }); if (response?.HttpResponse is null) { return(null); } if (!response.Succeeded) { return(false); } User = new User { Id = response.Value.Id, Email = response.Value.Email, Role = response.Value.Role, AccessToken = response.Value.AccessToken, RefreshToken = response.Value.RefreshToken, Expires = response.Value.Expires }; await _localStorageService.SetItemAsync("user", User); return(true); }
public async Task <LoginResponseDto> Login(LoginRequestDto userFromAuthentication) { var content = JsonConvert.SerializeObject(userFromAuthentication); var bodyContent = new StringContent(content, Encoding.UTF8, "application/json"); var response = await _client.PostAsync("api/account/login", bodyContent); var contentTemp = await response.Content.ReadAsStringAsync(); var result = JsonConvert.DeserializeObject <LoginResponseDto>(contentTemp); if (response.IsSuccessStatusCode) { await _localStorage.SetItemAsync(MagicStrings.Local_Token, result.Token); //await _localStorage.SetItemAsync(MagicStrings.Local_UserDetails, result.User); ((MyAuthenticationStateProvider)_authStateProvider).NotifyUserLoggedIn(result.Token); _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", result.Token); return(new LoginResponseDto { IsSuccessful = true }); } else { return(result); } }
public async Task <LoginResult> Login(LoginModel loginModel) { JsonContent content = JsonContent.Create(loginModel); var response = await _httpClient.PostAsync(GetApiEndpoint("login"), content); var loginResult = System.Text.Json.JsonSerializer.Deserialize <LoginResult>( await response.Content.ReadAsStringAsync(), new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); if (!response.IsSuccessStatusCode) { loginResult.Successful = false; loginResult.Error = "Invalid username or password"; return(loginResult); } loginResult.Successful = true; await _localStorage.SetItemAsync("authToken", loginResult.Token); ((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(loginModel.Email); _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", loginResult.Token); return(loginResult); }
public async Task <LoginResult> Login(LoginModel loginModel) { //var loginAsJson = JsonSerializer.Serialize(loginModel); //var response = await _httpClient.PostAsync("api/Login", new StringContent(loginAsJson, Encoding.UTF8, "application/json")); //var loginResult = JsonSerializer.Deserialize<LoginResult>(await response.Content.ReadAsStringAsync(), new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); //if (loginResult.Successful) //{ // await _localStorage.SetItemAsync("authToken", loginResult.Token); // ((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(loginResult.Token); // _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", loginResult.Token); // return loginResult; //} //return loginResult; var result = await _httpClient.PostJsonAsync <LoginResult>("api/Login", loginModel); if (result.Successful) { await _localStorage.SetItemAsync("authToken", result.Token); ((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(result.Token); _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", result.Token); return(result); } return(result); }
private async Task SetCultureInternal(string cultureName) { var newCulture = GetCulture(cultureName); await _localStorageService.SetItemAsync(_blazorCultureKey, newCulture.Name).ConfigureAwait(true); CultureInfo.CurrentCulture = newCulture; }
public async Task SaveApiKey() { if (HasApiKey) { await LocalStorage.SetItemAsync("GitterKey", apiKey); } }
public async Task <Result> Login(LoginRequestModel model) { var response = await httpClient.PostAsJsonAsync("api/identity/login", model); if (!response.IsSuccessStatusCode) { var errors = await response.Content.ReadFromJsonAsync <string[]>(); return(Result.Failure(errors)); } var responseAsString = await response.Content.ReadAsStringAsync(); var responseObject = JsonSerializer.Deserialize <LoginResponseModel>(responseAsString, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); var token = responseObject.Token; await localStorage.SetItemAsync("authToken", token); ((ApiAuthenticationStateProvider)authenticationStateProvider).MarkUserAsAuthenticated(model.Email); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); return(Result.Success); }
private async Task <AuthenticationState> CreateAuthenticationState(User user) { await _localStorageService.SetItemAsync("authToken", user.Token); _currentUserService.CurrentUser = user; _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", user.Token); var handler = new JwtSecurityTokenHandler(); var token = handler.ReadJwtToken(user.Token); var claims = token.Claims.ToList(); var roleClaim = claims.FirstOrDefault(c => c.Type == "role"); if (roleClaim != null) { var newRoleClaim = new Claim(ClaimTypes.Role, roleClaim.Value); claims.Add(newRoleClaim); } Console.WriteLine(JsonSerializer.Serialize(claims)); var claimsPrincipal = new ClaimsPrincipal( new ClaimsIdentity(claims, "apiauth")); //var claimsPrincipal = new ClaimsPrincipal( // new ClaimsIdentity(new[] { new Claim("id", user.Id.ToString()) }, "apiauth")); return(new AuthenticationState(claimsPrincipal)); }
public async Task <bool> Authenticate(string email, string password) { try { AuthenticationRequest authenticationRequest = new AuthenticationRequest() { Email = email, Password = password }; var authenticationResponse = await _client.AuthenticateAsync(authenticationRequest); if (authenticationResponse.Token != string.Empty) { await _localStorage.SetItemAsync("token", authenticationResponse.Token); ((CustomAuthenticationStateProvider)_authenticationStateProvider).SetUserAuthenticated(email); _client.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", authenticationResponse.Token); return(true); } return(false); } catch { return(false); } }
async Task MarkUserAsAuthenticated(string token) { await localStorage.SetItemAsync("authToken", token); ((ApiAuthenticationStateProvider)authenticationStateProvider).MarkUserAsAuthenticated(token); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", token); }
public async Task <string> LoginUserAsync(LoginModel model) { var client = _clientFactory.CreateClient(); var response = await client.PostAsJsonAsync <LoginModel>($"{_baseURL}Login", model); if (response.IsSuccessStatusCode) { var result = await response.Content.ReadFromJsonAsync <UserResponse>(); var userInfo = new UserModel() { AccessToken = result.Message, }; var handler = new JwtSecurityTokenHandler(); var token = handler.ReadJwtToken(result.Message); userInfo.UserName = token.Claims.First(c => c.Type == "UserName").Value; await _storageService.SetItemAsync("user", userInfo); await _autenticationStateProvide.GetAuthenticationStateAsync(); return(string.Empty); } else { var result = await response.Content.ReadFromJsonAsync <UserResponse>(); return(result.Message); } }
public async Task <bool> Login(LoginModel user) { if (user == null) { return(false); } var response = await _client.PostAsJsonAsync(Endpoints.LoginEndpoint, user); if (!response.IsSuccessStatusCode) { return(false); } var content = await response.Content.ReadAsStringAsync(); var token = JsonConvert.DeserializeObject <TokenResponse>(content); //Store Token await _localStorage.SetItemAsync("authToken", token.Token); //Change auth state of app await((ApiAuthenticationStateProvider)_authenticationStateProvider).LoggedIn(); _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", token.Token); return(true); }
public async Task <bool> Login(TokenRequest user) { var request = new HttpRequestMessage(HttpMethod.Post, Endpoints.LoginEndpoint); var myData = new { Phone = user.Phone, Password = user.Password }; request.Content = new StringContent(JsonConvert.SerializeObject(myData), Encoding.UTF8, "application/json"); var client = _client.CreateClient(); HttpResponseMessage response = await client.SendAsync(request); var content = await response.Content.ReadAsStringAsync(); var result = JsonConvert.DeserializeObject <Wrapper.Result <TokenResponse> >(content); //Store Token await _localStorage.SetItemAsync("authToken", result.Data.Token); //Change auth state of app await((ApiAuthenticationStateProvider)_authenticationStateProvider) .LoggedIn(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", result.Data.Token); return(true); }
public async Task <List <TLookupData> > List() { string key = typeof(TLookupData).Name; var cacheEntry = await _localStorageService.GetItemAsync <CacheEntry <List <TLookupData> > >(key); if (cacheEntry != null) { _logger.LogInformation($"Loading {key} from local storage."); if (cacheEntry.DateCreated.AddMinutes(1) > DateTime.UtcNow) { return(cacheEntry.Value); } else { _logger.LogInformation($"Cache expired; removing {key} from local storage."); await _localStorageService.RemoveItemAsync(key); } } var types = await _catalogTypeService.List(); var entry = new CacheEntry <List <TLookupData> >(types); await _localStorageService.SetItemAsync(key, entry); return(types); }
public async Task <RepositoryResponce> Login(UserLoginDTO userData) { if (userData == null) { return(RepositoryResponce.ArgumentNullResponce); } System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12; using var client = _ClientFactory.CreateClient(); string url = Flurl.Url.Combine(apiUrl, ConventionalUrls.LoginRelativeUrl); HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, url) { Content = new StringContent(JsonConvert.SerializeObject(userData), Encoding.UTF8, MediaTypeNames.Application.Json) }; var responce = await client.SendAsync(httpRequestMessage); if (!responce.IsSuccessStatusCode) { return(RepositoryResponce.StatusCodeResponce(responce.StatusCode)); } else { var loginData = JsonConvert.DeserializeObject <Data.DTOs.SessionDataObject>(await responce.Content.ReadAsStringAsync()); await _LocalStorage.SetItemAsync(ConventionalKeys.TokenStorageKey, loginData.Token); await((ApiAuthentificationStateProvider)_AuthenticationStateProvider).LoggedIn(); client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue( "bearer", loginData.Token); var reponse = RepositoryResponce.StatusCodeResponce(responce.StatusCode); reponse.Message = loginData.Answer; return(reponse); } }
private async Task <string> RefreshTokenEndPoint(TokenModel tokenModel) { var response = await _httpClient.PostAsJsonAsync <TokenModel>("/account/activate-token-by-refreshtoken", tokenModel); if (!response.IsSuccessStatusCode) { return(string.Empty); } AuthResponse authResponse = await response.Content.ReadFromJsonAsync <AuthResponse>(); await _localStorageService.SetItemAsync <string>("token", authResponse.Token); await _localStorageService.SetItemAsync <string>("refreshToken", authResponse.RefreshToken); return(authResponse.Token); }
/// <summary> /// Login user to service /// </summary> /// <param name="loginModel"></param> /// <returns></returns> public async Task <LoginResult> Login(LoginInput loginModel) { var lr = new LoginResult { Successful = false, Error = "" }; var token = await GetAuthToken(loginModel.Username, loginModel.Password); await _localStorage.SetItemAsync(Const.TokenKey, token); if (string.IsNullOrWhiteSpace(token.AuthToken)) { return(lr); } await((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(token); _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(Const.TokenApiKey, token.AuthToken); lr.Successful = true; lr.Token = token.AuthToken; return(lr); }
public async Task <UserSignInResultDto> Login(UserLoginDto userLogin) { var result = await requestService.PostAsync <UserLoginDto, UserSignInResultDto>( $"{apiSettings.IndentityUrl}/authentication/login", userLogin); if (result.Success) { await localStorage.SetItemAsync("authToken", result.Token); await localStorage.SetItemAsync("authUser", result.User); ((ApiAuthenticationStateProvider)authenticationStateProvider).MarkUserAsAuthenticated(result.User); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", result.Token); } return(result); }
public async Task <SignInResult> PasswordSignInAsync(string userName, string password) { if (string.IsNullOrEmpty(userName)) { throw new ArgumentNullException(nameof(userName)); } if (password is null) { throw new ArgumentNullException(nameof(password)); } if (!_systemSetting.UserName.Equals(userName) || !_systemSetting.Password.Equals(password)) { return(SignInResult.Failed); } try { var token = _jsonWebTokenService.GetJsonWebToken(); await _localStorageService.SetItemAsync(STORAGE_KEY, token); NotifyAuthenticationStateChanged(Task.FromResult(new AuthenticationState(new ClaimsPrincipal()))); return(SignInResult.Success); } catch (Exception ex) { _logger.LogError(ex, ex.Message); return(SignInResult.Failed); } }
private async Task <ClaimsPrincipal> GetPrincipal() { var version = await localStorage.GetItemAsync <string>("version"); var correctVersion = configuration.GetSection("Version").Value; if (version != correctVersion) { await localStorage.ClearAsync(); await localStorage.SetItemAsync(nameof(version), correctVersion); } try { var telegramUserInfo = await localStorage.GetItemAsync <TelegramUserInfo>("telegramUserInfo"); if (telegramUserInfo == null) { Console.WriteLine("no user info"); return(new ClaimsPrincipal()); } else { var(success, claims) = await TryGetInternalClaims(telegramUserInfo); if (success) { var tgIdentity = TelegramWidgetClaimsIdentityGenerator.GetIdentityForUserInfo(telegramUserInfo); var internalIdentity = new ClaimsIdentity(claims, InternalClaimConstants.IDENTITY_AUTH_TYPE); return(new ClaimsPrincipal(new ClaimsIdentity[] { tgIdentity, internalIdentity })); } else { Console.WriteLine("can't login"); return(new ClaimsPrincipal()); } } } catch (Exception ex) { Console.WriteLine("exception"); Console.WriteLine(ex); return(new ClaimsPrincipal()); } }
private async Task SaveToken(HttpResponseMessage response) { var responseContent = await response.Content.ReadAsStringAsync(); var jwt = Json.Deserialize <JwToken>(responseContent); await _localStorage.SetItemAsync("authToken", jwt.Token); }
public async Task AuthenticateUserAsync(string userToken) { await _localStorage.SetItemAsync(TokenKey, userToken); var authState = this.BuildAuthenticationStateFromToken(userToken); NotifyAuthenticationStateChanged(Task.FromResult(authState)); }
public async Task Login(string token) { await _localStorage.SetItemAsync(_tokenkey, token); var authState = buildAuthenticationState(token); NotifyAuthenticationStateChanged(Task.FromResult(authState)); }