async Task LoginFacebookAsync(AuthNetwork authNetwork)
{
try
{
if (_facebookService.IsLoggedIn)
{
_facebookService.Logout();
}
EventHandler <FBEventArgs <string> > userDataDelegate = null;
userDataDelegate = async(object sender, FBEventArgs <string> e) =>
{
switch (e.Status)
{
case FacebookActionStatus.Completed:
var facebookProfile = await Task.Run(() => JsonConvert.DeserializeObject <FacebookProfile>(e.Data));
var socialLoginData = new NetworkAuthData
{
Id = facebookProfile.Id,
Logo = authNetwork.Icon,
Background = authNetwork.Background,
Picture = facebookProfile.Picture.Data.Url,
Name = $"{facebookProfile.FirstName} {facebookProfile.LastName}",
};
await App.Current.MainPage.Navigation.PushModalAsync(new HomePage(socialLoginData));
break;
case FacebookActionStatus.Canceled:
await App.Current.MainPage.DisplayAlert("Facebook Auth", "Canceled", "Ok");
break;
case FacebookActionStatus.Error:
await App.Current.MainPage.DisplayAlert("Facebook Auth", "Error", "Ok");
break;
case FacebookActionStatus.Unauthorized:
await App.Current.MainPage.DisplayAlert("Facebook Auth", "Unauthorized", "Ok");
break;
}
_facebookService.OnUserData -= userDataDelegate;
};
_facebookService.OnUserData += userDataDelegate;
string[] fbRequestFields = { "email", "first_name", "picture", "gender", "last_name" };
string[] fbPermisions = { "email" };
await _facebookService.RequestUserDataAsync(fbRequestFields, fbPermisions);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
public async Task <IActionResult> SendMessage([FromBody] ConnectorMessage messageData, [FromQuery] string networkName)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
NetworkAuthData account = await _context
.Accounts
.Include(a => a.User)
.FirstOrDefaultAsync(a => a.PlatformName == networkName && a.AccessToken == messageData.AccessToken);
if (account == null)
{
return(BadRequest("Wrong account info"));
}
Message message = new Message()
{
NetworkName = networkName,
Text = messageData.Text,
NetworkUserId = messageData.SenderId
};
_aggregatorSender.SendMessage(account.User, message);
return(Ok());
}
async Task LoginFacebookAsync()
{
try
{
if (_facebookService.IsLoggedIn)
{
_facebookService.Logout();
}
EventHandler <FBEventArgs <string> > userDataDelegate = null;
userDataDelegate = async(object sender, FBEventArgs <string> e) =>
{
if (e == null)
{
return;
}
switch (e.Status)
{
case FacebookActionStatus.Completed:
var facebookProfile = await Task.Run(() => JsonConvert.DeserializeObject <FacebookProfile>(e.Data));
var socialLoginData = new NetworkAuthData
{
Email = facebookProfile.Email,
Name = $"{facebookProfile.FirstName}",
LastName = $"{facebookProfile.LastName}",
Id = facebookProfile.Id,
Picture = "http://graph.facebook.com/" + facebookProfile.Id + "/picture?type=normal"
};
var navigationParams = new NavigationParameters
{
{ "NetworkAuthData", socialLoginData }
};
await _navigationService.NavigateAsync("DashboardPage", navigationParams);
break;
case FacebookActionStatus.Canceled:
break;
}
_facebookService.OnUserData -= userDataDelegate;
};
_facebookService.OnUserData += userDataDelegate;
string[] fbRequestFields = { "email", "first_name", "gender", "last_name" };
string[] fbPermisions = { "email" };
await _facebookService.RequestUserDataAsync(fbRequestFields, fbPermisions);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
public async void SendAccountData(Connector connector, NetworkAuthData authData)
{
var serializedMessage = await Task.Run(() => JsonConvert.SerializeObject(new
{
accessToken = authData.AccessToken
}));
var content = new StringContent(serializedMessage, Encoding.UTF8, "application/json");
sender.SendPostRequest(content, connector.Url);
}
async Task LoginFacebookAsync()
{
//Perform your "Can Login?" logic here...
try
{
if (_facebookService.IsLoggedIn)
{
_facebookService.Logout();
}
EventHandler <FBEventArgs <string> > userDataDelegate = null;
userDataDelegate = async(object sender, FBEventArgs <string> e) =>
{
if (e == null)
{
return;
}
switch (e.Status)
{
case FacebookActionStatus.Completed:
var facebookProfile = await Task.Run(() => JsonConvert.DeserializeObject <FacebookProfile>(e.Data));
var socialLoginData = new NetworkAuthData
{
Email = facebookProfile.Email,
Name = $"{facebookProfile.FirstName} {facebookProfile.LastName}",
Id = facebookProfile.Id
};
await App.Current.MainPage.Navigation.PushModalAsync(new MainMenuPage());
break;
case FacebookActionStatus.Canceled:
break;
}
_facebookService.OnUserData -= userDataDelegate;
};
_facebookService.OnUserData += userDataDelegate;
string[] fbRequestFields = { "email", "first_name", "gender", "last_name" };
string[] fbPermisions = { "email" };
await _facebookService.RequestUserDataAsync(fbRequestFields, fbPermisions);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
public void OnNavigatedTo(INavigationParameters parameters)
{
var data = parameters?.GetValue <NetworkAuthData>("NetworkAuthData");
_data = data;
HelloString = $"Olá, {data?.Name}!";
var user = UserController.GetUserByEmail(data.Email);
Bubbles = new ObservableCollection <BubbleHeader>()
{
new BubbleHeader {
Icon = "Marker", Title = $"{user.TotalDistance} km", Description = "Distância Percorrida", IconColor = "#00C1D4"
},
new BubbleHeader {
Icon = "Check", Title = user.TotalTrip, Description = "Viagens Finalizadas", IconColor = "#33AC2E"
},
};
}
public async Task <IActionResult> AttachAccount([FromBody] Account account, [FromQuery] string userToken)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = await _context
.Users
.Include(u => u.Accounts)
.FirstOrDefaultAsync(u => u.UserToken == userToken);
if (user == null)
{
return(NotFound("Invalid token"));
}
Connector connector = _context
.Connectors
.FirstOrDefault(c => c.NetworkName == account.NetworkName);
if (connector == null)
{
return(NotFound("Not implemented network"));
}
NetworkAuthData networkAuthData = new NetworkAuthData()
{
UserId = user.Id,
User = user,
PlatformName = account.NetworkName,
AccessToken = account.AccessToken
};
_connectorSender.SendAccountData(connector, networkAuthData);
user.Accounts.Add(networkAuthData);
await _context.SaveChangesAsync();
return(Ok());
}
public HomePage(NetworkAuthData networkAuthData)
{
BindingContext = networkAuthData;
InitializeComponent();
}
async Task LoginInstagramAsync(AuthNetwork authNetwork)
{
EventHandler <string> onSuccessDelegate = null;
EventHandler <string> onErrorDelegate = null;
EventHandler onCancelDelegate = null;
onSuccessDelegate = async(s, a) =>
{
UserDialogs.Instance.ShowLoading("Loading");
var userResponse = await RestService.For <IInstagramApi>(InstagramApiUrl).GetUser(a);
if (userResponse.IsSuccessStatusCode)
{
var userDataString = await userResponse.Content.ReadAsStringAsync();
//Handling Encoding
var userDataStringFixed = System.Text.RegularExpressions.Regex.Unescape(userDataString);
var instagramUser = JsonConvert.DeserializeObject <InstagramUser>(userDataStringFixed);
var socialLoginData = new NetworkAuthData
{
Logo = authNetwork.Icon,
Picture = instagramUser.Data.ProfilePicture,
Background = authNetwork.Background,
Name = instagramUser.Data.FullName,
Id = instagramUser.Data.Id
};
UserDialogs.Instance.HideLoading();
await App.Current.MainPage.Navigation.PushModalAsync(new HomePage(socialLoginData));
}
else
{
//TODO: Handle instagram user info error
UserDialogs.Instance.HideLoading();
await UserDialogs.Instance.AlertAsync("Error", "Houston we have a problem", "Ok");
}
_oAuth2Service.OnSuccess -= onSuccessDelegate;
_oAuth2Service.OnCancel -= onCancelDelegate;
_oAuth2Service.OnError -= onErrorDelegate;
};
onErrorDelegate = (s, a) =>
{
_oAuth2Service.OnSuccess -= onSuccessDelegate;
_oAuth2Service.OnCancel -= onCancelDelegate;
_oAuth2Service.OnError -= onErrorDelegate;
Debug.WriteLine($"ERROR: Instagram, MESSAGE: {a}");
};
onCancelDelegate = (s, a) =>
{
_oAuth2Service.OnSuccess -= onSuccessDelegate;
_oAuth2Service.OnCancel -= onCancelDelegate;
_oAuth2Service.OnError -= onErrorDelegate;
};
_oAuth2Service.OnSuccess += onSuccessDelegate;
_oAuth2Service.OnCancel += onCancelDelegate;
_oAuth2Service.OnError += onErrorDelegate;
_oAuth2Service.Authenticate(InstagramClientId, InstagramScope, new Uri(InstagramAuthorizationUrl), new Uri(InstagramRedirectUrl));
}
async Task LoginGoogleAsync(AuthNetwork authNetwork)
{
try
{
if (!string.IsNullOrEmpty(_googleService.AccessToken))
{
//Always require user authentication
_googleService.Logout();
}
EventHandler <GoogleClientResultEventArgs <GoogleUser> > userLoginDelegate = null;
EventHandler <GoogleClientErrorEventArgs> userLoginFailDelegate = null;
userLoginDelegate = async(object sender, GoogleClientResultEventArgs <GoogleUser> e) =>
{
switch (e.Status)
{
case GoogleActionStatus.Completed:
#if DEBUG
var googleUserString = JsonConvert.SerializeObject(e.Data);
Debug.WriteLine($"Google Logged in succesfully: {googleUserString}");
#endif
var socialLoginData = new NetworkAuthData
{
Id = e.Data.Id,
Logo = authNetwork.Icon,
Foreground = authNetwork.Foreground,
Background = authNetwork.Background,
Picture = e.Data.Picture.AbsoluteUri,
Name = e.Data.Name,
};
await App.Current.MainPage.Navigation.PushModalAsync(new HomePage(socialLoginData));
break;
case GoogleActionStatus.Canceled:
await App.Current.MainPage.DisplayAlert("Google Auth", "Canceled", "Ok");
break;
case GoogleActionStatus.Error:
await App.Current.MainPage.DisplayAlert("Google Auth", "Error", "Ok");
break;
case GoogleActionStatus.Unauthorized:
await App.Current.MainPage.DisplayAlert("Google Auth", "Unauthorized", "Ok");
break;
}
_googleService.OnLogin -= userLoginDelegate;
};
userLoginFailDelegate = async(object sender, GoogleClientErrorEventArgs e) =>
{
var x = e;
_googleService.OnError -= userLoginFailDelegate;
};
_googleService.OnLogin += userLoginDelegate;
_googleService.OnError += userLoginFailDelegate;
await _googleService.LoginAsync();
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
