/// <summary>
/// Send post request to Verify User Record.
/// </summary>
/// <returns>A new instance of the <see cref="VerifyPasswordResponse"/> class.</returns>
/// <param name="request">An instance of the <see cref="VerifyPasswordRequest"/> class.</param>
public async Task <VerifyPasswordResponse> VerifyAsync(VerifyPasswordRequest request)
{
var response = await this.SendAsync <VerifyPasswordRequest, VerifyPasswordResponse>(
HttpMethod.Post, $"phe/v1/verify-password", request).ConfigureAwait(false);
return(response);
}
private async Task InternalLoginAsync(string email, string pwd)
{
var authOptions = new FirebaseAuthOptions(Secrets.FIREBASE_API_KEY);
var firebaseAuthService = new FirebaseAuthService(authOptions);
var request = new VerifyPasswordRequest()
{
Email = email,
Password = pwd
};
try
{
VerifyPasswordResponse response = await firebaseAuthService.VerifyPassword(request);
_currentUser = new User
{
Email = response.Email,
Token = response.IdToken
};
}
catch (FirebaseAuthException e)
{
_telemetry.LogError("Error in firebase login", e);
}
}
public async Task <User> LoginUser(LoginInput User)
{
var authOptions = new FirebaseAuthOptions("AIzaSyDHXodPd4jjaXSzwxrdCzJMptaiMPNeYME");
var firebase = new FirebaseAuthService(authOptions);
User user = new User();
// Set up data
var request = new VerifyPasswordRequest()
{
Email = User.Email,
Password = User.Password
};
// Execute login query
var response = await firebase.VerifyPassword(request);
// Get Data
user.Email = response.Email;
user.IdToken = response.IdToken;
user.ExpiresIn = response.ExpiresIn;
user.LocalId = response.LocalId;
return(user);
}
internal async Task <string> ConnectApiAsync(string apiKey)
{
var authOptions = new FirebaseAuthOptions(apiKey);
var firebase = new FirebaseAuthService(authOptions);
var request = new VerifyPasswordRequest()
{
Email = EMAIL,
Password = PASSWORD
};
string authToken = String.Empty;
try
{
var response = await firebase.VerifyPassword(request);
authToken = response.IdToken;
//authToken = response.RefreshToken;
}
catch (FirebaseAuthException e)
{
Application.Restart();
}
return(authToken);
}
public async Task <string> Authenticate(LoginApiRequest request)
{
var firebaseRequest = new VerifyPasswordRequest()
{
Email = request.Login,
Password = request.Password
};
var response = await _firebaseAuthService.VerifyPasswordAsync(firebaseRequest);
return(response.IdToken);
}
private async void login_Click(object sender, EventArgs e)
{
if (email_text.Text.Count() > 0 && password_text.Text.Count() > 0)
{
VerifyPasswordRequest request = new VerifyPasswordRequest();
request.Email = email_text.Text;
request.Password = password_text.Text;
try
{
VerifyPasswordResponse response = await fService.VerifyPassword(request);
if (remember_me_check.Checked)
{
Settings.Default["email"] = email_text.Text;
Settings.Default["password"] = password_text.Text;
Settings.Default.Save();
}
String uid = response.LocalId;
FirebaseResponse user_record = await client.GetAsync("users/" + uid);
UserData data = user_record.ResultAs <UserData>();
if (data.role == UserData.ROLE_ORGANIZER || data.role == UserData.ROLE_ADMIN)
{
DeliveryApp deliveryApp = new DeliveryApp();
deliveryApp.ShowDialog();
}
else if (data.role == UserData.ROLE_FULFILLMENT)
{
FulFillmentStuffForm target = new FulFillmentStuffForm();
target.Show();
Close();
}
}
catch (FirebaseAuthException ex)
{
String msg = ex.Message;
if (remember_me_check.Checked)
{
/*Settings.Default["email"] = "";
* Settings.Default["password"] = "";
* Settings.Default.Save();*/
}
MessageBox.Show("Email address or password may not correct.");
}
catch (Exception ex) {
MessageBox.Show("Network status may not good, Try again later.");
Close();
}
}
}
private async Task <VerifyPasswordResponse> VerifyPassword_ValidCredentials()
{
using (var service = CreateService())
{
var request = new VerifyPasswordRequest()
{
Email = knownValidEmail,
Password = knownValidPassword
};
return(await service.VerifyPassword(request));
}
}
public async Task VerifyPassword_DisabledCredentials_ThrowsUserDisabled()
{
using (var service = CreateService())
{
var request = new VerifyPasswordRequest()
{
Email = knownDisabledEmail,
Password = knownDisabledPassword
};
//NOTE: Make sure the user is disabled!
var exception = await Assert.ThrowsAsync <FirebaseAuthException>(async() => await service.VerifyPassword(request));
Assert.Equal(FirebaseAuthMessageType.UserDisabled, exception.Error?.MessageType);
}
}
public async Task VerifyPassword_NoEmail_ThrowsInvalidEmail()
{
using (var service = CreateService())
{
var request = new VerifyPasswordRequest()
{
Email = "",
Password = "******"
};
var exception = await Assert.ThrowsAsync <FirebaseAuthException>(async() => await service.VerifyPassword(request));
Assert.Equal(FirebaseAuthMessageType.InvalidEmail, exception.Error?.MessageType);
}
}
public async Task VerifyPassword_NoPassword_ThrowsMissingPassword()
{
using (var service = CreateService())
{
var request = new VerifyPasswordRequest()
{
Email = "*****@*****.**",
Password = ""
};
var exception = await Assert.ThrowsAsync <FirebaseAuthException>(async() => await service.VerifyPassword(request));
Assert.Equal(FirebaseAuthMessageType.MissingPassword, exception.Error?.MessageType);
}
}
public async Task VerifyPassword_WrongPassword_ThrowsInvalidPassword()
{
using (var service = CreateService())
{
var request = new VerifyPasswordRequest()
{
Email = knownValidEmail,
Password = "******"
};
var exception = await Assert.ThrowsAsync <FirebaseAuthException>(async() => await service.VerifyPassword(request));
Assert.Equal(FirebaseAuthMessageType.InvalidPassword, exception.Error?.MessageType);
}
}
public async Task VerifyPassword_RandomEmail_ThrowsEmailNotFound()
{
using (var service = CreateService())
{
var request = new VerifyPasswordRequest()
{
Email = GenerateValidEmail(),
Password = "******"
};
var exception = await Assert.ThrowsAsync <FirebaseAuthException>(async() => await service.VerifyPassword(request));
Assert.Equal(FirebaseAuthMessageType.EmailNotFound, exception.Error?.MessageType);
}
}
/// <summary>
/// Change the current context to login.
/// </summary>
public async Task <bool> LoginAsync()
{
if (Email != string.Empty && Password != string.Empty)
{
var request = new VerifyPasswordRequest()
{
Email = this.Email,
Password = this.Password,
};
try
{
var response = await _firebase.VerifyPassword(request);
if (response != null)
{
var userData = await _firebase.GetUserData(new GetUserDataRequest()
{
IdToken = response.IdToken
});
if (userData != null)
{
//save a flag to the application data to know that a user is logged in
SettingsImp.UserValue = JsonConvert.SerializeObject(userData.users[0]);
if (CheckIfVerified(userData))
{
await Xamarin.Forms.DependencyService.Get <IFirebaseAuthenticator>().LoginWithEmailPassword(this.Email, this.Password);
//SettingsImp.UserNameValue = await GetUserDataAsync();
return(true);
}
else
{
if (await _pageDialogservice.DisplayAlertAsync("Not Verified", "To use this account please verfiy your email address.", "Resend Email", "Cancel"))
{
var sendverification = await _firebase.SendVerification(
new SendVerificationEmailRequest()
{
RequestType = "VERIFY_EMAIL",
IdToken = response.IdToken,
});
}
}
}
}
}
catch (FirebaseAuthException e)
{
await _pageDialogservice.DisplayAlertAsync("Error", GetRigthErrorMessage(e), "Cancel");
}
//could not find user
return(false);
}
else
{
//if the login process failed
return(false);
}
}
/// <summary>
/// Verifies the password for a given user. This is equivalent to signing the user in
/// with an email and password.
/// </summary>
public async Task <VerifyPasswordResponse> VerifyPassword(VerifyPasswordRequest request)
{
return(await Post <VerifyPasswordResponse>(RelyingPartyUrl("verifyPassword"), request));
}
