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