public bool Create(AuthCredential credential)
{
dbContext.AuthCredentials.Add(credential);
int result = dbContext.SaveChanges();
return(result > 0);
}
private void FirebaseAuthWithGoogle(GoogleSignInAccount acct)
{
//Google Credential
AuthCredential credential = GoogleAuthProvider.GetCredential(acct.IdToken, null);
_auth.SignInWithCredential(credential).AddOnCompleteListener(this, this);
}
async System.Threading.Tasks.Task LinkAccount()
{
// Make sure form is valid
if (!ValidateLinkForm())
{
return;
}
// Get email and password from form
var email = mEmailField.Text;
var password = mPasswordField.Text;
// Create EmailAuthCredential with email and password
AuthCredential credential = EmailAuthProvider.GetCredential(email, password);
// Link the anonymous user to the email credential
ShowProgressDialog();
// [START link_credential]
try {
var result = await mAuth.CurrentUser.LinkWithCredentialAsync(credential);
} catch (Exception ex) {
Toast.MakeText(this, "Authentication failed.", ToastLength.Short).Show();
}
// [START_EXCLUDE]
HideProgressDialog();
// [END_EXCLUDE]
// [END link_credential]
}
public async Task <AuthCredential> ProcessApprovedAuthCallbackAsync(RequestToken token)
{
if (token == null)
{
throw new ArgumentNullException("token", "RequestToken cannot be null");
}
if (string.IsNullOrWhiteSpace(token.Token))
{
throw new ArgumentNullException("token", "RequestToken.Token must not be null");
}
var oauthRequestToken = new AsyncOAuth.RequestToken(token.Token, token.Secret);
var authorizer = new OAuthAuthorizer(ConsumerKey, ConsumerSecret);
var accessToken = await authorizer.GetAccessToken(Constants.BaseApiUrl + Constants.TemporaryCredentialsAccessTokenUri, oauthRequestToken, token.Verifier);
var result = new AuthCredential
{
AuthToken = accessToken.Token.Key,
AuthTokenSecret = accessToken.Token.Secret,
UserId = accessToken.ExtraData["encoded_user_id"].FirstOrDefault()
};
return(result);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_main);
// To use this you have to set up a project in the Firebase console and add the google-services.json file
var baseOptions = FirebaseOptions.FromResource(Application.Context);
var options = new FirebaseOptions.Builder(baseOptions)
.SetProjectId(baseOptions.StorageBucket.Split('.')[0])
.Build();
var fa = FirebaseApp.InitializeApp(Application.Context, options, "Xamarin");
//FirebaseApp fa = FirebaseApp.InitializeApp(Application.Context);
mAuth = FirebaseAuth.GetInstance(fa);
if (mAuth == null)
{
Console.WriteLine("mAuth is null");
}
AuthCredential credential = EmailAuthProvider.GetCredential("*****@*****.**", "password");
var creds = mAuth.SignInWithEmailAndPassword("*****@*****.**", "password"); // Here the program crashes due to a null mAuth
}
private async Task <IFirebaseAuthResult> LinkWithCredentialAsync(AuthCredential credential)
{
IAuthResult authResult = null;
try
{
authResult = await _user.LinkWithCredentialAsync(credential);
}
catch (Firebase.Auth.FirebaseAuthException ex)
{
Console.WriteLine(ex.Message);
throw GetFirebaseAuthException(ex);
}
catch (RuntimeWrappedException ex)
{
var authEx = ex.WrappedException as Firebase.Auth.FirebaseAuthException;
throw GetFirebaseAuthException(ex);
}
catch
{
Console.WriteLine("Uh oh");
throw;
}
return(new FirebaseAuthResult(authResult));
}
async Task <AccountResponse> LoginToFirebase(AuthCredential credential)
{
try
{
var signinResult = await FirebaseAuth.Instance.SignInWithCredentialAsync(credential);
var user = signinResult.User;
var split = user.DisplayName.Split(' ');
return(new AccountResponse
{
Success = true,
User = new Clients.Portable.User()
{
Id = user.Uid,
Email = user.Email,
FirstName = split?.FirstOrDefault(),
LastName = split?.LastOrDefault()
}
});
}
catch (System.Exception ex)
{
return(new AccountResponse
{
Success = false,
Error = ex.Message
});
}
}
/// <summary>
/// Attaches the given phone credentials to the user. This allows the user to sign in to this account in the future with credentials for such provider.
/// </summary>
/// <param name="verificationId">The verification ID obtained by calling VerifyPhoneNumber.</param>
/// <param name="verificationCode">The 6 digit SMS-code sent to the user.</param>
/// <returns>Updated current account</returns>
public IObservable <IFirebaseAuthResult> LinkWithPhoneNumber(string verificationId, string verificationCode)
{
AuthCredential credential = PhoneAuthProvider.GetCredential(verificationId, verificationCode);
return(_user.LinkWithCredentialAsync(credential).ToObservable().Select(x => new FirebaseAuthResult(x)));
//return LinkWithCredentialAsync(credential).ToObservable();
}
public async Task <IActionResult> Upload(UploadZipFileModel uploadZipFileModel)
{
if (ModelState.IsValid)
{
var result = ZipFileProcessor.Process(uploadZipFileModel.ZipFile);
if (result.IsFailure)
{
Logger.LogError(result.Error);
ModelState.AddModelError("ZipFile", result.Error);
return(View(uploadZipFileModel));
}
var auth = new AuthCredential
{
Password = uploadZipFileModel.Password,
Username = uploadZipFileModel.Username
};
var responseMessage = await ZipContentStorageHelper.SendContent(result.Value, auth);
if (responseMessage.IsFailure)
{
Logger.LogError(responseMessage.Error, result.Value);
ModelState.AddModelError("ZipFile", responseMessage.Error);
return(View(uploadZipFileModel));
}
return(RedirectToAction("Success"));
}
return(View(uploadZipFileModel));
}
//Final step. Take this authorization information and use it in the app
public async Task <ActionResult> Callback()
{
RequestToken token = new RequestToken();
token.Token = Request.Params["oauth_token"];
token.Secret = Session["FitbitRequestTokenSecret"].ToString();
token.Verifier = Request.Params["oauth_verifier"];
string consumerKey = ConfigurationManager.AppSettings["FitbitConsumerKey"];
string consumerSecret = ConfigurationManager.AppSettings["FitbitConsumerSecret"];
//this is going to go back to Fitbit one last time (server to server) and get the user's permanent auth credentials
//create the Authenticator object
var authenticator = new Authenticator(consumerKey, consumerSecret);
//execute the Authenticator request to Fitbit
AuthCredential credential = await authenticator.ProcessApprovedAuthCallbackAsync(token);
//here, we now have everything we need for the future to go back to Fitbit's API (STORE THESE):
// credential.AuthToken;
// credential.AuthTokenSecret;
// credential.UserId;
// For demo, put this in the session managed by ASP.NET
Session["FitbitAuthToken"] = credential.AuthToken;
Session["FitbitAuthTokenSecret"] = credential.AuthTokenSecret;
Session["FitbitUserId"] = credential.UserId;
return(RedirectToAction("Index", "Home"));
}
private object Upload(byte[] data, string filename, AuthCredential credential, string remotePath = null)
{
string file = System.IO.Path.GetFileName(filename);
OAuthToken token = new OAuthToken();
token.AccessToken = credential.Token;
token.AuthenticationToken = credential.Authentication;
token.RefreshToken = credential.Refresh;
dynamic result = null;
OAuthError error = null;
string destinationFolderId = null;
try
{
destinationFolderId = createFolderIfNotExists("", remotePath, token, out error);
}
catch (UnauthorizedAccessException)
{
RequestAccessTokenByRefreshToken(token.RefreshToken, MogConstants.SKYDRIVE_REDIRECTURL, out token, out error);
credential.Token = token.AccessToken;
credential.Authentication = token.AuthenticationToken;
credential.Refresh = token.RefreshToken;
this.repoAuthCredential.SaveChanges(credential);
destinationFolderId = createFolderIfNotExists("", remotePath, token, out error);
}
var url = string.Format("{0}/{1}/files/{2}?access_token={3}",
skydriveApiUrl,
destinationFolderId,
filename,
token.AccessToken);
try
{
var request = (HttpWebRequest)HttpWebRequest.Create(url);
request.Method = "PUT";
request.ContentLength = data.Length;
using (var dataStream = request.GetRequestStream())
{
dataStream.Write(data, 0, data.Length);
}
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string json = reader.ReadToEnd();
result = JsonConvert.DeserializeObject <dynamic>(json);
}
catch (Exception e)
{
//todo : do something with exception
}
return(result);
}
async void ProcessSignInResult(Intent data)
{
GoogleSignInResult signInResult = Auth.GoogleSignInApi.GetSignInResultFromIntent(data);
if (signInResult.IsSuccess)
{
AuthCredential credential = GoogleAuthProvider.GetCredential(signInResult.SignInAccount.IdToken, null);
try
{
IAuthResult authResult = await FirebaseAuth_.SignInWithCredentialAsync(credential);
FirebaseUser user = authResult.User;
User.myInfo.PhotoPath = signInResult.SignInAccount.PhotoUrl.ToString();
User.Uid = signInResult.SignInAccount.Id;
User.Token = signInResult.SignInAccount.IdToken;
User.myInfo.NickName = signInResult.SignInAccount.DisplayName;
StartActivity(new Intent(Application.Context, typeof(MainActivity)));
}
catch (Exception ex)
{
// new Handler(MainLooper).Post(() => new Android.App.AlertDialog.Builder(this).SetMessage("var_TeamRecord 등록 실패\n\n" + ex).Show());
}
}
else
{
StartActivity(new Intent(Application.Context, typeof(MainActivity)));
}
}
async void ProcessSignInResult(Intent data)
{
GoogleSignInResult signInResult = Auth.GoogleSignInApi.GetSignInResultFromIntent(data);
if (signInResult.IsSuccess)
{
AuthCredential credential = GoogleAuthProvider.GetCredential(signInResult.SignInAccount.IdToken, null);
try
{
User.PhotoPath = signInResult.SignInAccount.PhotoUrl.ToString();
User.Uid = signInResult.SignInAccount.Id;
User.Token = signInResult.SignInAccount.IdToken;
User.NickName = signInResult.SignInAccount.DisplayName;
IAuthResult authResult = await FirebaseAuth_.SignInWithCredentialAsync(credential);
FirebaseUser user = authResult.User;
}
catch (Exception ex)
{
// new Handler(MainLooper).Post(() => new AlertDialog.Builder(this).SetMessage("파이어베이스 등록 실패\n\n" + ex).Show());
}
}
else
{
}
}
public MogFile UploadFile(string filename, AuthCredential credential, string remotePath = null)
{
//upload file to skydrive
//if everything is OK, return the file
byte[] data = System.IO.File.ReadAllBytes(filename);
return(UploadFile(data, filename, credential, remotePath));
}
private void FirebaseAuthWithGoogle(GoogleSignInAccount acct)
{
Log.Debug(Tag, "FirebaseAuthWithGoogle:" + acct.Id);
AuthCredential credential = GoogleAuthProvider.GetCredential(acct.IdToken, null);
mAuth.SignInWithCredential(credential).AddOnCompleteListener(this, this);
}
public async void OnAuthenticationCompleted(GoogleOAuthToken token)
{
// SFSafariViewController doesn't dismiss itself
DismissViewController(true, null);
DisplayLoadingIndicator();
var googleUserInfo = await _authViewModel.RetrieveGoogleUserInfoAsync(token.TokenType, token.AccessToken);
var firebaseUserInfo = await _authViewModel.AuthenticateUserWithFirebaseAsync(googleUserInfo);
if (firebaseUserInfo != null)
{
AuthCredential credential = GoogleAuthProvider.GetCredential(token.IdToken, token.AccessToken);
AuthDataResult result = await FirebaseManager.Auth.SignInAndRetrieveDataWithCredentialAsync(credential);
token.SaveToDevice();
googleUserInfo.SaveToDevice();
firebaseUserInfo.SaveToDevice();
PerformSegueToHome(googleUserInfo.GivenName);
}
else
{
await _authViewModel.RevokeTokenAsync(token.TokenType, token.AccessToken);
RemoveLoadingIndicator();
txtNotAuthorizedMessage.Text = _authViewModel.FirebaseNotAuthorizedErrorMessage;
GoogleLoginButton.Hidden = true;
}
}
public string AskForRegistrationUrl(UserProfileInfo user, string redirectUrl, out int tempCredentialId)
{
var _client = new DropNetClient(MogConstants.DROPBOX_KEY, MogConstants.DROPBOX_SECRET);
UserLogin login = _client.GetToken();
// UserLogin login = _client.GetAccessToken();
var url = _client.BuildAuthorizeUrl(login, redirectUrl);
var query = repoAuthCredential.GetByUserId(user.Id);
List <AuthCredential> existingCredentials = null;
if (query != null)
{//TODO : gerer le cas des accounts multiples
existingCredentials = query.Where(a => a.CloudService == CloudStorageServices.Dropbox).ToList();
foreach (var credential in existingCredentials)
{
repoAuthCredential.Delete(credential);
}
}
AuthCredential newCredential = new AuthCredential();
newCredential.Token = login.Token;
newCredential.Secret = login.Secret;
newCredential.UserId = user.Id;
newCredential.CloudService = CloudStorageServices.Dropbox;
this.repoAuthCredential.Create(newCredential);
tempCredentialId = newCredential.Id;
return(url);
}
private void handleFacebookAccessToken(AccessToken accessToken)
{
//Facebook Credential
AuthCredential credential = FacebookAuthProvider.GetCredential(accessToken.Token);
_auth.SignInWithCredential(credential).AddOnCompleteListener(this, this);
}
//Final step. Take this authorization information and use it in the app
public ActionResult Callback()
{
string OAuthToken = Request.Params["oauth_token"];
string OAuthVerifier = Request.Params["oauth_verifier"];
string ConsumerKey = ConfigurationManager.AppSettings["FitbitConsumerKey"];
string ConsumerSecret = ConfigurationManager.AppSettings["FitbitConsumerSecret"];
//this is going to go back to Fitbit one last time (server to server) and get the user's permanent auth credentials
//create the Authenticator object
Fitbit.Api.Authenticator authenticator = new Fitbit.Api.Authenticator(ConsumerKey,
ConsumerSecret,
"http://api.fitbit.com/oauth/request_token",
"http://api.fitbit.com/oauth/access_token",
"http://api.fitbit.com/oauth/authorize");
//execute the Authenticator request to Fitbit
AuthCredential credential = authenticator.ProcessApprovedAuthCallback(OAuthToken, OAuthVerifier);
//here, we now have everything we need for the future to go back to Fitbit's API (STORE THESE):
// credential.AuthToken;
// credential.AuthTokenSecret;
// credential.UserId;
// For demo, put this in the session managed by ASP.NET
Session["FitbitAuthToken"] = credential.AuthToken;
Session["FitbitAuthTokenSecret"] = credential.AuthTokenSecret;
Session["FitbitUserId"] = credential.UserId;
return(RedirectToAction("Index", "Home"));
}
public static async Task <bool> FirebaseAuthWithGoogle(FirebaseAuth firebaseAuth, GoogleSignInAccount acct)
{
try
{
if (Connectivity.NetworkAccess == NetworkAccess.Internet)
{
AuthCredential credential = GoogleAuthProvider.GetCredential(acct.IdToken, null);
IAuthResult result = await firebaseAuth.SignInWithCredentialAsync(credential);
if (result != null && result.User != null)
{
return(true);
}
else
{
return(false);
}
}
}
catch (FirebaseNetworkException)
{
throw;
}
return(false);
}
public static IAuthCredential Create(AuthCredential authCredential)
{
return(authCredential switch
{
OAuthCredential oAuthCredential => new OAuthCredentialWrapper(oAuthCredential),
PhoneAuthCredential phoneAuthCredential => new PhoneAuthCredentialWrapper(phoneAuthCredential),
_ => new AuthCredentialWrapper(authCredential)
});
private void FacebookAuthComplete(object sender, AuthenticatorCompletedEventArgs e)
{
Log.Debug(Tag, "FacebookAuthComplete:" + e.IsAuthenticated);
if (e.IsAuthenticated)
{
var token = e.Account.Properties["access_token"];
AuthCredential credential = FacebookAuthProvider.GetCredential(token);
mAuth.SignInWithCredential(credential);
}
}
public void Can_Retrieve_Access_Token_And_Access_Token_Secret()
{
AuthCredential authCredential = authenticator.ProcessApprovedAuthCallback(Configuration.TempAuthToken, Configuration.TempAuthVerifier);
Assert.IsNotNull(authCredential.AuthToken);
Console.WriteLine("AuthToken: " + authCredential.AuthToken);
Assert.IsNotNull(authCredential.AuthTokenSecret);
Console.WriteLine("AuthTokenSecret: " + authCredential.AuthTokenSecret);
Assert.IsNotNull(authCredential.UserId); //encoded Fitbit UserId
Console.WriteLine("Fitbit UserId: " + authCredential.UserId);
}
private async Task <IFirebaseAuthResult> SignInAsync(AuthCredential credential)
{
try
{
IAuthResult authResult = await _auth.SignInWithCredentialAsync(credential);
return(new FirebaseAuthResult(authResult));
}
catch (FirebaseException ex)
{
throw GetFirebaseAuthException(ex);
}
}
private async Task <IFirebaseAuthResult> SignInAsync(AuthCredential credential)
{
try
{
AuthDataResult authResult = await Auth.DefaultInstance.SignInAndRetrieveDataAsync(credential);
return(new FirebaseAuthResult(authResult));
}
catch (NSErrorException ex)
{
throw GetFirebaseAuthException(ex);
}
}
private async Task <IFirebaseAuthResult> LinkWithCredentialAsync(AuthCredential credential)
{
try
{
AuthDataResult authResult = await _user.LinkAndRetrieveDataAsync(credential);
return(new FirebaseAuthResult(authResult));
}
catch (NSErrorException ex)
{
throw GetFirebaseAuthException(ex);
}
}
private void TwitterAuthComplete(object sender, AuthenticatorCompletedEventArgs e)
{
Log.Debug(Tag, "TwitterAuthComplete:" + e.IsAuthenticated);
if (e.IsAuthenticated)
{
var token = e.Account.Properties["oauth_token"];
var secret = e.Account.Properties["oauth_token_secret"];
AuthCredential credential = TwitterAuthProvider.GetCredential(token, secret);
mAuth.SignInWithCredential(credential);
}
}
public async Task <bool> SignInWithGoogle(string token)
{
try
{
AuthCredential credential = GoogleAuthProvider.GetCredential(token, null);
await FirebaseAuth.GetInstance(MainActivity.app).SignInWithCredentialAsync(credential);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
static void SaveCredentials(AuthCredential credentials, string userName)
{
try
{
var path = GetAppDataPath(userName);
var serializer = new XmlSerializer(typeof(AuthCredential));
TextWriter writer = new StreamWriter(path);
serializer.Serialize(writer, credentials);
writer.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void RegisterAccount(OAuthToken token, UserProfileInfo user)
{
LiveAuthClient auth = new LiveAuthClient(clientId, clientSecret, MogConstants.SKYDRIVE_REDIRECTURL);
AuthCredential credential = new AuthCredential();
credential.CloudService = CloudStorageServices.Skydrive;
credential.Token = token.AccessToken;
credential.Refresh = token.RefreshToken;
credential.Authentication = token.AuthenticationToken;
credential.Status = CredentialStatus.Approved;
credential.UserId = user.Id;
credential.Login = auth.GetUserId(token.AuthenticationToken);
this.repoAuthCredential.Create(credential);
}