private void Logout() { _signalHelperFacade.LoginSignalHelper.Logout(); LoggedIn = false; LoggedOut?.Invoke(string.Empty); RaiseCanExecuteChanged(); }
private static void WaitForLockFile() { Watcher.Path = LeaguePath; Watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastAccess; Watcher.Filter = "lockfile"; FileSystemEventHandler OnLockFileChanged = (o, e) => { if (IsActive || LockFile.Equals("")) { return; } Init(); }; Watcher.Created += OnLockFileChanged; Watcher.Changed += OnLockFileChanged; Watcher.Deleted += (o, e) => { IsActive = false; Stopped?.Invoke(null, EventArgs.Empty); Connection = null; CurrentSummoner = null; LoggedOut?.Invoke(null, EventArgs.Empty); }; Watcher.EnableRaisingEvents = true; if (LockFileLocation != null && File.Exists(LockFileLocation)) { Init(); } }
private async Task DiscordShardedClientOnLoggedOut() { if (LoggedOut != null) { await LoggedOut.Invoke(this).ConfigureAwait(false); } }
private void LoginBroswer_LoadCompleted(object sender, NavigationEventArgs e) { Console.WriteLine(e.Uri); WebBrowser webBrowser = (WebBrowser)sender; if (e.Uri.ToString().StartsWith("https://signin.ea.com/p/web2/login")) { this.Show(); this.WindowState = WindowState.Normal; this.ShowInTaskbar = true; Loggeding2?.Invoke(); } else if (Regex.Match(e.Uri.ToString(), "https://www.origin.com/[a-z]+/[a-z-]+/oauth/login").Success) { this.Hide(); webBrowser.Navigate("https://accounts.ea.com/connect/auth?client_id=ORIGIN_JS_SDK&response_type=token&redirect_uri=nucleus:rest&prompt=none&release_type=prod"); Loggeding1?.Invoke(); } else if (e.Uri.ToString().StartsWith("https://accounts.ea.com/connect/auth")) { //this.Hide(); dynamic document = webBrowser.Document; string json = document.documentElement.innerText; LoggedIn?.Invoke(json); } else if (Regex.Match(e.Uri.ToString(), "https://www.origin.com/[a-z]+/[a-z-]+/oauth/logout").Success) { this.Hide(); LoggedOut?.Invoke(); } }
public async Task LogoutAsync() { try { Username = null; Token = null; IsAuthorized = false; var res = await Client.UpdateNotificationAsync(Notification.FcmToken, NotificationType.Disabled); if (res.Success) { Debug.WriteLine("Notification Unregistered"); } else { await Acr.UserDialogs.UserDialogs.Instance.AlertAsync("Failed to unregister notification"); } Client.SetAuthorizationToken(null); } catch (Exception ex) { await Acr.UserDialogs.UserDialogs.Instance.AlertAsync(ex.ToString(), "Unknown error occured"); } LoggedOut?.Invoke(this, EventArgs.Empty); }
public Login(LoginPacketWriter loginPacketWriter, ScriptMessageSender messageSender, LoginDeniedMessageHandler deniedMessageHandler, LoginAcknowledgedMessageHandler loginAcknowledgedMessage, LogoutAcknowledgeMessageHandler logoutMessageHandler) { if (deniedMessageHandler == null) { throw new ArgumentNullException(nameof(deniedMessageHandler)); } if (loginAcknowledgedMessage == null) { throw new ArgumentNullException(nameof(loginAcknowledgedMessage)); } if (logoutMessageHandler == null) { throw new ArgumentNullException(nameof(logoutMessageHandler)); } deniedMessageHandler.LoginFailureReceived += DeniedMessageHandlerOnLoginFailureReceived; loginAcknowledgedMessage.LoginAcknowledgementReceived += sender => LoginAcknowledged?.Invoke(this, new LoginAcknowledgedArgs()); logoutMessageHandler.LogoutAcknowledgmentReceived += sender => LoggedOut?.Invoke(this); _LoginPacketWriter = loginPacketWriter ?? throw new ArgumentNullException(nameof(loginPacketWriter)); _MessageSender = messageSender ?? throw new ArgumentNullException(nameof(messageSender)); }
/// <summary> /// Logs out user and deletes user from currentSession /// </summary> /// <param name="commandInfo"></param> /// <returns></returns> public override bool Execute(CommandInfo commandInfo) { LogOut(); LoggedOut?.Invoke(this, new EventArgs()); return(true); }
/// <summary> /// Triggers the <see cref="LoggedOut"/> event /// </summary> protected void TriggerLoggedOutEvent(IUserExtension user) { if (LoggedOut != null) { LoggedOut.Invoke(user); } }
//private void _authStateProvider_AuthenticationStateChanged(Task<AuthenticationState> task) { // var state = task.Result.User.Identity.IsAuthenticated; // Console.WriteLine("!! _authStateProvider_AuthenticationStateChanged login " + state); //} public async Task <sr <string> > Login(Login login) { Console.WriteLine("!! AuthService login"); var response = await _http.PostAsJsonAsync("api/auth/login", login); var content = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { await _localStorageService.SetItemAsync("token", content); Console.WriteLine("!! AuthService login - is logged in!"); IsLoggedIn = true; _dispatcher.Dispatch(new Store.SessionUseCase.LoggedInViaTokenAction()); LoggedIn?.Invoke(); return(sr <string> .GetSuccess(content)); } else { await _localStorageService.SetItemAsync("token", string.Empty); IsLoggedIn = false; _dispatcher.Dispatch(new Store.SessionUseCase.LoggedOutSessionAction()); LoggedOut?.Invoke(); return(sr <string> .Get(content)); } }
public async Task <string> GetAccessTokenAsync() { var acquireTokenSuccess = await AcquireTokenSilentAsync(); if (acquireTokenSuccess) { return(_authenticationResult.AccessToken); } else { try { // Interactive authentication is required var accounts = await _client.GetAccountsAsync(); _authenticationResult = await _client.AcquireTokenInteractive(_scopes) .WithAccount(accounts.FirstOrDefault()) .ExecuteAsync(); return(_authenticationResult.AccessToken); } catch (MsalException) { // AcquireTokenSilent and AcquireTokenInteractive failed, the session will be closed. _authenticationResult = null; LoggedOut?.Invoke(this, EventArgs.Empty); return(string.Empty); } } }
public Task LogoutAsync() { _isLoggedin = false; LoggedOut?.Invoke(this, EventArgs.Empty); return(Task.CompletedTask); }
private bool DoLogout() { Account.OAuthAccount = null; ForgetAccessData(); Debug.WriteLine("User logged out"); LoggedOut?.Invoke(this, new EventArgs()); return(true); }
public async void Logout() { Dictionary <string, string> args = new Dictionary <string, string>(); args.Add("access_token", _accessToken); await GetResponse("logout", args); IsLoggedIn = false; LoggedOut?.Invoke(this, EventArgs.Empty); }
public static bool Logout() { var res = Account.Instance.Logout(); if (res) { LoggedOut?.Invoke(); } return(res); }
internal void OnLoggedOut(LogoutEventArgs args) { if (args == null) { throw new ArgumentNullException(nameof(args)); } IsLoggedIn = false; LoggedOut?.Invoke(this, args); }
private void InternalLogout(Exception exception = null) { lock (_lock) { _secureStorage.Delete(StorageKey); LoggedOut?.Invoke(new LoggedOutEventArgs() { Exception = exception }); } }
/// <summary> /// Logs out. /// </summary> /// <param name="player">The player.</param> protected virtual void LogOut(Player player) { if (!OnlinePlayers.Remove(player)) { return; } PlayerRepository.UpdatePlayerAsync(player); LoggedOut?.Invoke(this, player); Logger.Info($"[{player.Username}] logout succeed"); }
public async Task <sr <string> > Logout() { //TODO: totaly fake, only delets token from localStorage. // if saved, it could still be used await _localStorageService.SetItemAsync("token", string.Empty); IsLoggedIn = false; _dispatcher.Dispatch(new Store.SessionUseCase.LoggedOutSessionAction()); LoggedOut?.Invoke(); await _authStateProvider.GetAuthenticationStateAsync(); return(sr <string> .GetSuccess("Loguut")); }
public async Task <bool> Logout() { if (!IsLoggedIn()) { Debug.WriteLine("Logout: user is not logged in!"); LoggedOut?.Invoke(this, new EventArgs()); return(true); // L'utente non è loggato } // Non c'è un logout dall'App... l'utente dovrebbe fare il logout da Google. // Per questo motivo, semplicemente mi dimentico dell'access token. return(await Task.FromResult(DoLogout())); }
/// <summary> /// Executes the session's logout process. /// <remarks> /// This action is idempotent, calling this multiple times has no ill effect. /// </remarks> /// </summary> public void Logout() { if (!Active) { return; } // Send a logout message Send("5", Outbound.Clear()); Active = false; LoggedOut?.Invoke(this); }
public static async Task Logout() { Serializer.DeleteCacheFile(); Data.Value.Account = null; Data.Value.Code = null; Data.Value.RedirectUrl = null; Data.Value.TokenData = null; Data.Value.TokenDataCreatedAt = DateTime.MinValue; Data.Value.TwitchUsers = null; Save(); Account.Instance.Reset(); await ApiWrapper.UpdateUploadTokenStatus(); LoggedOut?.Invoke(); }
public static async Task <bool> Logout() { try { await AzureWebApi.Logout(); Xamarin.Essentials.SecureStorage.RemoveAll(); LoggedOut?.Invoke(); return(true); } catch { return(false); } }
private void OnUserDisconnect(IPeer peer) { var extension = peer.GetExtension <UserExtension>(); if (extension == null) { return; } _loggedInUsers.Remove(extension.Username.ToLower()); peer.Disconnected -= OnUserDisconnect; LoggedOut?.Invoke(extension); }
public void Logout() { if (Busy) { return; } Busy = true; Services.Host.AuthService.Logout(); Busy = false; LoggedOut?.Invoke(this, EventArgs.Empty); Busy = false; }
public async Task <bool> LogOut() { await _logger.Info("Logging out..."); TaskCompletionSource <bool> result = new TaskCompletionSource <bool>(); result.SetResult(true); await _logger.Info("Set auth to null"); await _interopService.SetLocalStorageItem("auth", null); LoggedOut?.Invoke(this, new EventArgs()); return(await result.Task); }
void SettingCellTapped(object sender, System.EventArgs e) { if (sender == DisconnectCell) { LoggedOut?.Invoke(this, new EventArgs()); Navigation.PopAsync(); } else if (sender == ThanksCell) { Device.OpenUri(new Uri(Constants.ApplicationUrl + "/home/thanks")); } else if (sender == ReportBugCell) { Device.OpenUri(new Uri("http://messier16.com/support.html")); } }
public async Task Logout() { OAuthData.Serializer.Delete(_data); _data.Account = null; _data.Code = null; _data.RedirectUrl = null; _data.TokenData = null; _data.TokenDataCreatedAt = DateTime.MinValue; _data.TwitchUsers = null; OAuthData.Serializer.Save(_data); _account.Reset(); _uploadTokenHistory.Write("Deleting token"); Load(); await _api.UpdateTokenStatus(); LoggedOut?.Invoke(); }
private void OnGatewayStateChanged(GatewayStatus newState) { switch (newState) { case GatewayStatus.Resuming: Resuming?.Invoke(); break; case GatewayStatus.Reconnecting: Reconnecting?.Invoke(); break; case GatewayStatus.Disconnected: LoggedOut?.Invoke(); break; } }
/// <summary> /// Initiates a log out. In the process, disconnects and connects /// back to the server to ensure no state data is left on the server. /// </summary> public void LogOut(IClientSocket connection) { if (!IsLoggedIn) { return; } IsLoggedIn = false; AccountInfo = null; if ((connection != null) && connection.IsConnected) { connection.Reconnect(); } LoggedOut?.Invoke(); }
/// <summary> /// Initiates a log out. In the process, disconnects and connects /// back to the server to ensure no state data is left on the server. /// </summary> public void LogOut(IClientSocket connection) { if (!IsLoggedIn) { return; } AccountInfo = null; if ((connection != null) && connection.IsConnected) { connection.Reconnect(); } if (LoggedOut != null) { LoggedOut.Invoke(); } }