private void Logout()
{
_signalHelperFacade.LoginSignalHelper.Logout();
LoggedIn = false;
LoggedOut?.Invoke(string.Empty);
RaiseCanExecuteChanged();
}
/// <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);
}
}
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 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);
}
}
}
void LoggedOutNotification(LoggedOut loggedOut)
{
_isConnected = false;
_isSessionCreated = false;
DeviceCanvas.SetActive(false);
LoggingCanvas.SetActive(true);
}
public Task LogoutAsync()
{
_isLoggedin = false;
LoggedOut?.Invoke(this, EventArgs.Empty);
return(Task.CompletedTask);
}
public async Task Handle(LoggedOut e, IMessageHandlerContext ctx)
{
var user = await _uow.Get <presentationUsers.Models.AuUserResponse>(e.UserId);
if (user == null)
{
return;
}
}
private bool DoLogout()
{
Account.OAuthAccount = null;
ForgetAccessData();
Debug.WriteLine("User logged out");
LoggedOut?.Invoke(this, new EventArgs());
return(true);
}
internal void OnLoggedOut(LogoutEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
IsLoggedIn = false;
LoggedOut?.Invoke(this, args);
}
public static bool Logout()
{
var res = Account.Instance.Logout();
if (res)
{
LoggedOut?.Invoke();
}
return(res);
}
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);
}
/// <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 Handle(LoggedOut e, IHandleContext ctx)
{
var user = await _uow.Get <presentationUsers.Models.AU_UserResponse>(e.UserId);
if (user == null)
{
return;
}
_Demo.Report("Logout", new { Name = user.Name, Id = user.Id, Email = user.Email });
}
private void InternalLogout(Exception exception = null)
{
lock (_lock)
{
_secureStorage.Delete(StorageKey);
LoggedOut?.Invoke(new LoggedOutEventArgs()
{
Exception = exception
});
}
}
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()));
}
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 void Handle(LoggedOut message)
{
ExecutePureCommand <CloseAllMessagesWindows>();
ExecutePureCommand <CloseAllConferencialMessagesWindows>();
_eventAggregator.Unsubscribe(this);
_container.BeginLifetimeScope();
var shellViewModel = _container.Resolve <ShellViewModel>();
_windowManager.ShowWindow(shellViewModel);
TryClose();
}
/// <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 void Logout()
{
if (Busy)
{
return;
}
Busy = true;
Services.Host.AuthService.Logout();
Busy = false;
LoggedOut?.Invoke(this, EventArgs.Empty);
Busy = false;
}
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 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"));
}
}
/// <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();
}
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;
}
}
public async Task UnsubscribesFromTheSignalAfterLogout()
{
var subject = new Subject <TimeSpan>();
BackgroundService.AppResumedFromBackground.Returns(subject.AsObservable());
var errors = Observable.Never <Exception>();
SyncManager.Errors.Returns(errors);
AutomaticSyncingService.SetupAutomaticSync(UserAccessManager);
LoggedIn.OnNext(DataSource);
SyncManager.ClearReceivedCalls();
LoggedOut.OnNext(Unit.Default);
subject.OnNext(MinimumTimeInBackgroundForFullSync);
await SyncManager.DidNotReceive().ForceFullSync();
}
/// <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();
}
}
