private async Task Authenticate(MobileServiceAuthenticationProvider provider) { try { WAMSRepositoryService service = Mvx.Resolve<IRepositoryService>() as WAMSRepositoryService; user = await service.MobileService .LoginAsync(this, provider); } catch (InvalidOperationException e) { } var vm = ViewModel as AuthViewModel; if (user != null) { vm.CreateUserCommand.Execute(user); } else { vm.BackCommand.Execute(null); } }
private async void Login(MobileServiceAuthenticationProvider provider) { var client = new MobileServiceClient(this.uriEntry.Value, this.keyEntry.Value); var user = await client.LoginAsync(this, provider); var alert = new UIAlertView("Welcome", "Your userId is: " + user.UserId, null, "OK"); alert.Show(); }
private async Task DoLoginAsync(MobileServiceAuthenticationProvider provider) { MobileServiceUser user; try { user = await DependencyService.Get<IMobileClient>().LoginAsync(provider); App.AuthenticatedUser = user; System.Diagnostics.Debug.WriteLine("Authenticated with user: "******"Authentication was cancelled")) { messageLabel.Text = "Authentication cancelled by the user"; } } catch (Exception ex) { messageLabel.Text = "Authentication failed"; } }
/// <summary> /// Starts the authentication process. /// </summary> /// <param name="provider">The provider to authenticate with.</param> public async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider) { try { var vault = new PasswordVault(); // Login with the identity provider. var user = await AzureAppService.Current .LoginAsync(provider); // Create and store the user credentials. var credential = new PasswordCredential(provider.ToString(), user.UserId, user.MobileServiceAuthenticationToken); vault.Add(credential); } catch (InvalidOperationException invalidOperationException) { if (invalidOperationException.Message .Contains("Authentication was cancelled by the user.")) { throw new AuthenticationCanceledException("Authentication canceled by user", invalidOperationException); } throw new AuthenticationException("Authentication failed", invalidOperationException); } catch (Exception e) { throw new AuthenticationException("Authentication failed", e); } }
private async Task Login(MobileServiceAuthenticationProvider provider) { var user = await _authenticationService.Login(provider); var userName = await GetIsOauthUserRegistered (user.UserId); await _databaseService.SaveCurrentUserAsync(new User { UserName = userName } ); await _databaseService.DeleteAllScheduledConferencesAsync (); var conferenceDtos = await _remoteConferenceService.LoadScheduledConferencesAsync (userName); foreach (var conferenceDto in conferenceDtos) { var dto = conferenceDto; dto.IsAddedToSchedule = true; var conference = await TaskEx.Run (() => Mapper.Map<Conference> (dto)); await _databaseService.SaveConferenceAsync (conference); foreach (var sessionDto in dto.Sessions) { SessionDto dto1 = sessionDto; var session = await TaskEx.Run(() => Mapper.Map<Session>(dto1)); session.ConferenceId = conference.Id; await _databaseService.SaveSessionAsync(session); foreach (var speakerDto in sessionDto.Speakers) { SpeakerDto speakerDto1 = speakerDto; var speaker = await TaskEx.Run(() => Mapper.Map<Speaker>(speakerDto1)); speaker.SessionId = session.Id; await _databaseService.SaveSpeakerAsync(speaker); } } } ShowViewModel<ConferencesTabViewModel> (); }
/// <summary> /// Tests the <see cref="MobileServiceClient.RefreshUserAsync"/> functionality on the platform. /// </summary> /// <param name="provider"> /// The provider with which to login. /// </param> /// <returns> /// The UserId and MobileServiceAuthentication token obtained from logging in. /// </returns> public static async Task<string> TestRefreshUserAsync(MobileServiceAuthenticationProvider provider) { string result; switch (provider) { case MobileServiceAuthenticationProvider.MicrosoftAccount: result = await TestMicrosoftAccountRefreshUserAsync(); break; case MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory: result = await TestAADRefreshUserAsync(); break; case MobileServiceAuthenticationProvider.Google: result = await TestGoogleRefreshUserAsync(); break; case MobileServiceAuthenticationProvider.Facebook: result = await TestFacebookRefreshUserAsync(); break; case MobileServiceAuthenticationProvider.Twitter: result = await TestTwitterRefreshUserAsync(); break; default: result = "MobileServiceAuthenticationProvider is not recognized."; break; } return result; }
public async Task<MobileServiceUser> LoginAsync(MobileServiceClient client, MobileServiceAuthenticationProvider provider) { try { var window = UIKit.UIApplication.SharedApplication.KeyWindow; var root = window.RootViewController; if(root != null) { var current = root; while(current.PresentedViewController != null) { current = current.PresentedViewController; } Settings.LoginAttempts++; var user = await client.LoginAsync(current, provider); Settings.AuthToken = user?.MobileServiceAuthenticationToken ?? string.Empty; Settings.UserId = user?.UserId ?? string.Empty; return user; } } catch(Exception e) { e.Data["method"] = "LoginAsync"; Xamarin.Insights.Report(e); } return null; }
private async System.Threading.Tasks.Task Authenticate(MobileServiceAuthenticationProvider msap) { try { user = await App.MobileService.LoginAsync(msap); } catch { } //THIS NEEDS TO BE FIXED TO STORE THE USER'S CREDENTIALs. //while (user == null) //{ // string message; // try // { // user = await App.MobileService.LoginAsync(msap); // message = // string.Format("You are now logged in - {0}", user.UserId); // } // catch (InvalidOperationException) // { // message = "You must log in. Login Required"; // } // MessageBox.Show(message); //} }
public async void loginAsync(MobileServiceAuthenticationProvider provider){ while(! await DependencyService.Get<IAuthenticate> ().loginAsync (MobileServiceAuthenticationProvider.Twitter)){ await DisplayAlert ("Login Fail", "Please try to login again", "OK"); } await DisplayAlert ("Login", "Logged in successfully as: " +App.MobileService.CurrentUser.UserId, "OK"); await Navigation.PushAsync (new Profile("twitter")); }
public LoginToken(MobileServiceUser user, MobileServiceAuthenticationProvider provider) { if (user != null && !string.IsNullOrWhiteSpace(user.MobileServiceAuthenticationToken)) { User = user; } Provider = provider; }
/// <summary> /// Instantiates a new instance of <see cref="MobileServiceTokenAuthentication"/>. /// </summary> /// <param name="client"> /// The client. /// </param> /// <param name="provider"> /// The authentication provider. /// </param> /// <param name="token"> /// The token. /// </param> public MobileServiceTokenAuthentication(MobileServiceClient client, MobileServiceAuthenticationProvider provider, JObject token) :base(client, provider) { Debug.Assert(client != null, "client should not be null."); Debug.Assert(token != null, "token should not be null."); this.client = client; this.token = token; }
public Task<MobileServiceUser> LoginAsync(IMobileServiceClient client, MobileServiceAuthenticationProvider provider, IDictionary<string, string> parameters = null) { try { return client.LoginAsync(Forms.Context, provider, parameters); } catch { } return null; }
/// <summary> /// Log a user into a Mobile Services application given a provider name and optional token object. /// </summary> /// <param name="provider" type="MobileServiceAuthenticationProvider"> /// Authentication provider to use. /// </param> /// <param name="client"> /// The <see cref="MobileServiceClient"/> to login with. /// </param> /// <param name="useSingleSignOn"> /// Indicates that single sign-on should be used. Single sign-on requires that the /// application's Package SID be registered with the Windows Azure Mobile Service, but it /// provides a better experience as HTTP cookies are supported so that users do not have to /// login in everytime the application is launched. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task<MobileServiceUser> LoginAsync(this IMobileServiceClient client, MobileServiceAuthenticationProvider provider, bool useSingleSignOn) { if(!useSingleSignOn) { return client.LoginAsync(provider); } MobileServiceSingleSignOnAuthentication auth = new MobileServiceSingleSignOnAuthentication(client, provider); return auth.LoginAsync(); }
public async Task<MobileServiceUser> LoginAsync(MobileServiceAuthenticationProvider provider) { try { return await mobileService.LoginAsync(provider); } catch (InvalidOperationException) { return null; } }
private static ZumoTest CreateLoginTest(MobileServiceAuthenticationProvider provider, bool useSingleSignOn) { string testName = string.Format("Login with {0}{1}", provider, useSingleSignOn ? " (using single sign-on)" : ""); return new ZumoTest(testName, async delegate(ZumoTest test) { var client = ZumoTestGlobals.Instance.Client; var user = await client.LoginAsync(provider, useSingleSignOn); test.AddLog("Logged in as {0}", user.UserId); return true; }); }
private async Task Login(MobileServiceAuthenticationProvider provider) { try { var user = await MobileService.LoginAsync(provider); AddToDebug("Logged in as {0}", user.UserId); } catch (Exception ex) { this.AddToDebug("Error: {0}", ex); } }
/// <summary> /// Initializes a new instance of the <see cref="MobileServiceAuthentication"/> class. /// </summary> /// <param name="client"> /// The <see cref="MobileServiceClient"/> associated with this /// MobileServiceLogin instance. /// </param> /// <param name="provider"> /// The <see cref="MobileServiceAuthenticationProvider"/> used to authenticate. /// </param> public MobileServiceAuthentication(IMobileServiceClient client, MobileServiceAuthenticationProvider provider) { Debug.Assert(client != null, "client should not be null."); this.Client = client; this.Provider = provider; string providerName = this.Provider.ToString().ToLower(); this.StartUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncUriFragment + "/" + providerName); this.EndUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncDoneUriFragment); }
public async Task<bool> loginAsync (MobileServiceAuthenticationProvider provider){ string message; try{ await App.MobileService.LoginAsync (Forms.Context,provider); return true; } catch(InvalidOperationException){ return false; } catch(Exception e){ return false; } }
private async Task LoginAsync(MobileServiceAuthenticationProvider provider) { var user = await authentication.LoginAsync(provider); if (user == null) { } else { applicationNavigation.ToCurrentExpenses(); } }
public async Task<bool> loginAsync (MobileServiceAuthenticationProvider provider){ string message; try{ var view = UIApplication.SharedApplication.KeyWindow.RootViewController; await App.MobileService.LoginAsync (view, provider); return true; } catch(InvalidOperationException){ return false; } catch(Exception e){ return false; } }
/// <summary> /// Tests the <see cref="MobileServiceClient.LoginAsync"/> functionality on the platform. /// </summary> /// <param name="provider">The provider with which to login. /// </param> /// <param name="useProviderStringOverload">Indicates if the call to <see cref="MobileServiceClient.LoginAsync"/> /// should be made with the overload where the provider is passed as a string. /// </param> /// <returns>The UserId and MobileServiceAuthentication token obtained from logging in.</returns> public static async Task<string> TestLoginAsync(MobileServiceAuthenticationProvider provider, bool useProviderStringOverload) { MobileServiceUser user; if (useProviderStringOverload) { user = await client.LoginAsync(provider.ToString()); } else { user = await client.LoginAsync(provider); } return string.Format("UserId: {0} Token: {1}", user.UserId, user.MobileServiceAuthenticationToken); }
public async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider) { try { await this.MobileService.LoginAsync(provider); await this.navigation.PopModalAsync(); } catch (InvalidOperationException) { // TODO: Show error //await this.OnShowErrorAsync?.Invoke("Authentication failed. Please try again."); } }
private async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider) { try { await MobileService.Instance.LoginAsync(this, provider); var intent = new Intent(this, typeof(MainActivity)); StartActivity(intent); } catch (InvalidOperationException) { // TODO: Show an error; } }
private async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider) { try { await MobileService.Instance.LoginAsync(this, provider); this.PerformSegue("ToList", this); } catch (InvalidOperationException) { // TODO: Show an error; var blah = 0; } }
public async Task<MobileServiceUser> LoginAsync(MobileServiceAuthenticationProvider provider) { //MobileServiceUser user = null; //try //{ // user = await App.MobileService.LoginAsync(Forms.Context, provider); //} //catch (Exception ex) //{ //} //return user; return await App.MobileService.LoginAsync(Forms.Context, provider); }
public Task<MobileServiceUser> LoginAsync(IMobileServiceClient client, MobileServiceAuthenticationProvider provider, IDictionary<string, string> parameters = null) { try { return client.LoginAsync(GetController(), provider, parameters); } catch (Exception e) { e.Data["method"] = "LoginAsync"; } return null; }
private static async Task<MobileServiceUser> Authenticate(MobileServiceAuthenticationProvider provider) { try { #if __IOS__ return await Client.LoginAsync(UIKit.UIApplication.SharedApplication.KeyWindow.RootViewController, provider); #elif WINDOWS_PHONE return await Client.LoginAsync(provider); #else return await Client.LoginAsync(Xamarin.Forms.Forms.Context, provider); #endif } catch (Exception ex) { return null; } }
private async System.Threading.Tasks.Task Autenticar(MobileServiceAuthenticationProvider provider) { while (user == null) { string mensagem = string.Empty; try { user = await App.MobileService.LoginAsync(provider); mensagem = string.Format("Usuário logado em: {0}", user.UserId); } catch(InvalidOperationException ex) { mensagem = "Usuário não Logado."; } MessageBox.Show(mensagem); } }
private async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider) { string message=null; try { currentUser = await App.MobileService .LoginAsync(provider); } catch (InvalidOperationException ioe) { currentUser = null; message = "ERROR : " + ioe.Message; } if (!string.IsNullOrEmpty(message)) await new MessageDialog(message, "ERREUR").ShowAsync(); }
public async Task<MobileServiceUser> LoginAsync(MobileServiceAuthenticationProvider provider) { var view = UIApplication.SharedApplication.KeyWindow.RootViewController; //MobileServiceUser user = null; //try //{ // UIViewController v = (UIViewController)view; // user = await App.MobileService.LoginAsync(v, provider); //} //catch (Exception ex) //{ //} //return user; return await App.MobileService.LoginAsync(view, provider); }
/// <summary> /// Log a user into a Mobile Services application given a provider name and optional token object. /// </summary> /// <param name="provider" type="MobileServiceAuthenticationProvider"> /// Authentication provider to use. /// </param> /// <param name="client"> /// The <see cref="MobileServiceClient"/> to login with. /// </param> /// <param name="useSingleSignOn"> /// Indicates that single sign-on should be used. Single sign-on requires that the /// application's Package SID be registered with the Microsoft Azure Mobile Service, but it /// provides a better experience as HTTP cookies are supported so that users do not have to /// login in everytime the application is launched. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this IMobileServiceClient client, MobileServiceAuthenticationProvider provider, bool useSingleSignOn) { return(LoginAsync(client, provider, useSingleSignOn, parameters: null)); }
/// <summary> /// Log a user into a Mobile Services application given a provider name and optional token object. /// </summary> /// <param name="provider" type="MobileServiceAuthenticationProvider"> /// Authentication provider to use. /// </param> /// <param name="client"> /// The <see cref="MobileServiceClient"/> to login with. /// </param> /// <param name="useSingleSignOn"> /// Indicates that single sign-on should be used. Single sign-on requires that the /// application's Package SID be registered with the Microsoft Azure Mobile Service, but it /// provides a better experience as HTTP cookies are supported so that users do not have to /// login in everytime the application is launched. /// </param> /// <param name="parameters"> /// Provider specific extra parameters that are sent as query string parameters to login endpoint. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this IMobileServiceClient client, MobileServiceAuthenticationProvider provider, bool useSingleSignOn, IDictionary <string, string> parameters) { return(LoginAsync(client, provider.ToString(), useSingleSignOn, parameters)); }
public Task LoginAsync(MobileServiceClient client, MobileServiceAuthenticationProvider provider) { return(client.LoginAsync(provider, null)); }
/// <summary> /// Log a user into a Mobile Services application given a provider name. /// </summary> /// <param name="client" type="Microsoft.WindowsAzure.MobileServices.IMobileServiceClient"> /// The MobileServiceClient instance to login with /// </param> /// <param name="context" type="Android.Content.Context"> /// The Context to display the Login UI in. /// </param> /// <param name="provider" type="MobileServiceAuthenticationProvider"> /// Authentication provider to use. /// </param> /// <param name="parameters"> /// Provider specific extra parameters that are sent as query string parameters to login endpoint. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this IMobileServiceClient client, Context context, MobileServiceAuthenticationProvider provider, IDictionary <string, string> parameters) { return(LoginAsync(client, context, provider.ToString(), parameters)); }
/// <summary> /// Log a user into a Mobile Services application given a provider name and optional token object. /// </summary> /// <param name="provider" type="MobileServiceAuthenticationProvider"> /// Authentication provider to use. /// </param> /// <param name="token" type="JObject"> /// Optional, provider specific object with existing OAuth token to log in with. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> internal async Task <MobileServiceUser> SendLoginAsync(MobileServiceAuthenticationProvider provider, JObject token = null) { if (this.LoginInProgress) { throw new InvalidOperationException(Resources.MobileServiceClient_Login_In_Progress); } if (!Enum.IsDefined(typeof(MobileServiceAuthenticationProvider), provider)) { throw new ArgumentOutOfRangeException("provider"); } string providerName = provider.ToString().ToLower(); this.LoginInProgress = true; try { JToken response = null; if (token != null) { // Invoke the POST endpoint to exchange provider-specific token for a Windows Azure Mobile Services token response = await this.RequestAsync("POST", LoginAsyncUriFragment + "/" + providerName, token); } else { // Use PhoneWebAuthenticationBroker to launch server side OAuth flow using the GET endpoint Uri startUri = new Uri(this.ApplicationUri, LoginAsyncUriFragment + "/" + providerName); Uri endUri = new Uri(this.ApplicationUri, LoginAsyncDoneUriFragment); PhoneAuthenticationResponse result = await PhoneWebAuthenticationBroker.AuthenticateAsync(startUri, endUri); if (result.ResponseStatus == PhoneAuthenticationStatus.ErrorHttp) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Resources.Authentication_Failed, result.ResponseErrorDetail)); } else if (result.ResponseStatus == PhoneAuthenticationStatus.UserCancel) { throw new InvalidOperationException(Resources.Authentication_Canceled); } int i = result.ResponseData.IndexOf("#token="); if (i > 0) { response = JToken.Parse(Uri.UnescapeDataString(result.ResponseData.Substring(i + 7))); } else { i = result.ResponseData.IndexOf("#error="); if (i > 0) { throw new InvalidOperationException(string.Format( CultureInfo.InvariantCulture, Resources.MobileServiceClient_Login_Error_Response, Uri.UnescapeDataString(result.ResponseData.Substring(i + 7)))); } else { throw new InvalidOperationException(Resources.MobileServiceClient_Login_Invalid_Response_Format); } } } // Get the Mobile Services auth token and user data this.currentUserAuthenticationToken = response.Get(LoginAsyncAuthenticationTokenKey).AsString(); this.CurrentUser = new MobileServiceUser(response.Get("user").Get("userId").AsString()); } finally { this.LoginInProgress = false; } return(this.CurrentUser); }
/// <summary> /// Log a user into a Mobile Services application given a provider name. /// </summary> /// <param name="client" type="Microsoft.WindowsAzure.MobileServices.IMobileServiceClient"> /// The MobileServiceClient instance to login with /// </param> /// <param name="context" type="Android.Content.Context"> /// The Context to display the Login UI in. /// </param> /// <param name="provider" type="MobileServiceAuthenticationProvider"> /// Authentication provider to use. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this IMobileServiceClient client, Context context, MobileServiceAuthenticationProvider provider) { return(LoginAsync(client, context, provider, parameters: null)); }
public Task LoginAsync(MobileServiceClient mobileServiceClient, MobileServiceAuthenticationProvider provider) { return(mobileServiceClient.LoginAsync(UIApplication.SharedApplication.KeyWindow.RootViewController, provider)); }