public static async Task <string> GetFacebookEmailAsync()
{
string email = string.Empty;
try
{
HttpClient httpClient = new HttpClient();
HttpResponseMessage httpResponse = await httpClient.GetAsync("https://graph.facebook.com/me?fields=email&access_token=" + SessionService.Token);
if (!httpResponse.IsSuccessStatusCode)
{
Debug.WriteLine($"Could not get FACEBOOK email. Status: {httpResponse.StatusCode}");
}
string data = await httpResponse.Content.ReadAsStringAsync();
FacebookData facebookData = JsonConvert.DeserializeObject <FacebookData>(data);
email = facebookData.Email;
}
catch (Exception ex)
{
TelemetryService.Instance.Record(ex);
}
return(await Task.FromResult(email));
}
public static async Task <List <FacebookUser> > DownloadFriendsList()
{
string result = String.Empty;
try
{
result = await DownloadStringAsync(
new Uri(
"https://graph.facebook.com/" +
"me/friends?fields=" +
"name," +
"picture," +
"installed" +
"&access_token=" + App.fbToken, UriKind.Absolute));
}
catch (Exception)
{ result = null; }
if (result != null)
{
FacebookData data = new FacebookData();
data = JsonConvert.DeserializeObject <FacebookData>(result);
return(data.friends);
}
else
{
return(null);
}
}
/*
* /// <summary>
* /// Initializes a new instance of the FacebookLayer class
* /// </summary>
* public FacebookLayer()
* {
* this.Auth = new Authorizer();
*
* if (this.Auth.Authorize())
* {
* this.FbClient = new FacebookClient(CurrentSession.AccessToken);
* this.User = new FacebookUser();
* try
* {
* var me = (IDictionary<string, object>) this.FbClient.Get("me");
*
* this.User.FacebookId = (string) me["id"];
* this.User.FacebookName = (string) me["first_name"];
* }
* catch
* {
* this.IsAccessTokenValid = false;
* return;
* }
*
* this.IsAccessTokenValid = true;
* IDictionary<string, object> friendsData = (IDictionary<string, object>) this.FbClient.Get("me/friends");
* this.facebookData = new FacebookData(this.User, friendsData);
* this.SortedFriends = this.facebookData.SortedFriends;
* }
* }
*/
/// <summary>
/// Initializes a new instance of the FacebookLayer class using authorization
/// </summary>
/// <param name="auth">authorization instance</param>
public FacebookLayer(Authorizer auth)
{
this.Auth = auth;
if (auth.Authorize())
{
this.FbClient = new FacebookClient(CurrentSession.AccessToken);
this.User = new FacebookUser();
try
{
var me = (IDictionary <string, object>) this.FbClient.Get("me");
this.User.FacebookId = (string)me["id"];
this.User.FacebookName = (string)me["first_name"];
}
catch
{
this.IsAccessTokenValid = false;
return;
}
this.IsAccessTokenValid = true;
IDictionary <string, object> friendsData = (IDictionary <string, object>)FbClient.Get("me/friends");
facebookData = new FacebookData(User, (IList <object>)friendsData["data"]);
}
}
public static void PublishSocial(SocialNetwork target, string data)
{
switch (target)
{
case SocialNetwork.Facebook:
{
FacebookData fb = ParseFacebookJson(data);
if (fb != null)
{
if (fb.Link == null)
{
if (fb.Title != null)
{
PublishSocialStatus(String.Format("{0}\n{1}", fb.Title, fb.Text ?? String.Empty));
}
else
{
PublishSocialStatus(fb.Text ?? String.Empty);
}
}
else
{
PublishSocialLink(fb.Title, fb.Text, fb.Link);
}
}
break;
}
case SocialNetwork.Twitter:
PublishSocialStatus(data);
break;
}
}
public void FacebookUpdateSnapshotsInDb()
{
List <FacebookAccount> accounts = new List <FacebookAccount>();
accounts.Add(new FacebookAccount {
Id = "NHLBruins", FriendlyName = "Boston Bruins"
});
accounts.Add(new FacebookAccount {
Id = "torontomapleleafs", FriendlyName = "Toronto Maple Leafs"
});
List <FacebookSnapshot> snapshots = FacebookData.UpdateSnapshotsInDb(accounts);
Assert.AreEqual(2, snapshots.Count, "There are 2 snapshots");
// Call Update again to make sure dupes are added
snapshots = FacebookData.UpdateSnapshotsInDb(accounts);
// Make sure we have the right items in the db
using (SportsDataContext db = new SportsDataContext())
{
List <FacebookSnapshot> snapshotsFromToday = (from s in db.FacebookSnapshot_DbSet.Include(x => x.FacebookAccount)
where DbFunctions.TruncateTime(s.DateOfSnapshot) == DbFunctions.TruncateTime(DateTime.UtcNow)
orderby s.FacebookAccount.Id
select s).ToList();
Assert.AreEqual(2, snapshotsFromToday.Count, "There are 2 snapshots, not 4");
Assert.AreEqual(DateTime.UtcNow.Date, snapshotsFromToday[0].DateOfSnapshot.Date, "The snapshots are from today");
Assert.AreEqual(snapshotsFromToday[0].DateOfSnapshot.Date, snapshotsFromToday[1].DateOfSnapshot.Date, "The snapshots are equal");
Assert.AreEqual("NHLBruins", snapshotsFromToday[0].FacebookAccount.Id, "The first snapshot is from NHLBruins");
Assert.AreEqual("torontomapleleafs", snapshotsFromToday[1].FacebookAccount.Id, "The first snapshot is from torontomapleleafs");
}
}
public static Task <List <facebookUser> > downloadFriendsList(string accessToken)
{
var downloadedList = new TaskCompletionSource <List <facebookUser> >();
FacebookClient fb = new FacebookClient(accessToken);
fb.GetCompleted += (o, e) =>
{
if (e.Error != null)
{
downloadedList.SetException(e.Error);
return;
}
string result = e.GetResultData().ToString();
FacebookData data = JsonConvert.DeserializeObject <FacebookData>(result);
IEnumerable <facebookUser> formatedList = from facebookUser F in data.friends
where F.usesApp == true
select F;
downloadedList.SetResult(formatedList.ToList());
};
fb.GetTaskAsync("/me/friends?fields=installed,name,picture");
return(downloadedList.Task);
}
public async Task <FacebookData> RetrieveCustomerFacebookData(string CustomerGUID)
{
//this method will only be called when we know that there is a profile.
var userToken = _context.CustomerFacebookLink.Where(a => a.CustomerGUID == CustomerGUID).Select(b => b.UserAccessToken).FirstOrDefault();
FacebookData dataForSpecifiedUser = await GetFacebookData(userToken);
return(dataForSpecifiedUser);
}
public ActionResult Social()
{
Dictionary <string, Exception> results = new Dictionary <string, Exception>();
if (this.IsKeyValid())
{
results.Add("FacebookData", this.Update(delegate() { FacebookData.UpdateAllSnapshotsInDb(); }));
results.Add("TwitterData", this.Update(delegate() { TwitterData.UpdateAllSnapshotsInDb(); }));
}
return(Json(results, JsonRequestBehavior.AllowGet));
}
public static async Task <List <FacebookUser> > DownloadFriendsList()
{
HttpClient client = new HttpClient();
string result = await client.GetStringAsync(String.Format(
"https://graph.facebook.com/{0}/friends?fields=name,about,picture&access_token={1}",
Utilities.fbUserID,
Utilities.fbToken));
FacebookData data = new FacebookData();
data = JsonConvert.DeserializeObject <FacebookData>(result);
return(data.friends);
}
public async Task <HttpResponseMessage> Post([FromBody] FacebookData data)
{
try
{
PostToGA("fb-test", "fb-received");
var entry = data.Entry.FirstOrDefault();
var change = entry?.Changes.FirstOrDefault();
if (change == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
//Generate user access token here https://developers.facebook.com/tools/accesstoken/
const string token = "EAAEbGnrCSeoBAHrRIMAmqjmrPRoo3zrEjoHCEQbJkv4JvSnBlC0PqwaOkruGUme2pATjbigamnmRymiBK51m3rrNjS0CDp8SodkTQFGjTUURNEyu1gkibYC3CBZBDck1dmi48poaRdWgbWEBGzPZCiT3uWZCnRhRDp0MR0AbNZBd6jvyV7ZBc43v7JWM2zq0ZD";
var leadUrl = $"https://graph.facebook.com/v2.10/{change.Value.LeadGenId}?access_token={token}";
var formUrl = $"https://graph.facebook.com/v2.10/{change.Value.FormId}?access_token={token}";
using (var httpClientLead = new HttpClient())
{
var response = await httpClientLead.GetStringAsync(formUrl);
if (!string.IsNullOrEmpty(response))
{
PostToGA("fb-test", "fb-get-form-success");
var jsonObjLead = JsonConvert.DeserializeObject <FacebookLeadFormData>(response);
//jsonObjLead.Name contains the lead ad name
//If response is valid get the field data
using (var httpClientFields = new HttpClient())
{
var responseFields = await httpClientFields.GetStringAsync(leadUrl);
if (!string.IsNullOrEmpty(responseFields))
{
PostToGA("fb-test", "fb-get-lead-success");
var jsonObjFields = JsonConvert.DeserializeObject <FacebookLeadData>(responseFields);
//jsonObjFields.FieldData contains the field value
}
}
}
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception ex)
{
Trace.WriteLine($"Error-->{ex.Message}");
Trace.WriteLine($"StackTrace-->{ex.StackTrace}");
return(new HttpResponseMessage(HttpStatusCode.BadGateway));
}
}
public async Task <FacebookData> GetFacebookData(string FacebookUserToken)
{
string _RequestUrl = $"https://graph.facebook.com/me?fields=id,name,age_range,gender,payment_pricepoints,likes.summary(true)&access_token=";
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(_RequestUrl);
if (response.IsSuccessStatusCode)
{
string json = await response.Content.ReadAsStringAsync();
FacebookData data = JsonConvert.DeserializeObject <FacebookData>(json);
return(data);
}
else
{
return(null);
}
}
public static async Task <string> GetFacebookEmailAsync()
{
string facebookTokenString = await SecureStorage.GetAsync("FACEBOOK");
string facebookToken = JsonConvert.DeserializeObject <FacebookToken>(facebookTokenString).AccessToken;
HttpClient httpClient = new HttpClient();
HttpResponseMessage httpResponse = await httpClient.GetAsync("https://graph.facebook.com/me?fields=email&access_token=" + facebookToken);
if (!httpResponse.IsSuccessStatusCode)
{
Debug.WriteLine($"Could not get FACEBOOK email. Status: {httpResponse.StatusCode}");
}
string data = await httpResponse.Content.ReadAsStringAsync();
FacebookData facebookData = JsonConvert.DeserializeObject <FacebookData>(data);
return(await Task.FromResult(facebookData.Email));
}
public JsonResult getProfile() //Without Postman
{ //https://graph.facebook.com/appid/accounts
FacebookData FacebookData = new FacebookData();
try
{
if (Session["Facebook_Token"] != null)
{
var content = client.DownloadString("https://graph.facebook.com/459893707813555?access_token=" + Session["Facebook_Token"].ToString());
serializer.MaxJsonLength = Int32.MaxValue;
FacebookData = serializer.Deserialize <FacebookData>(content);
log.Info("Serialization Completed");
}
}
catch (Exception ex)
{
log.Error("Error Message : " + ex.Message);
}
return(Json(FacebookData, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Get()
{
//Facebook
string content = await Facebook.GetContent("me", "video_lists{title,thumbnail},albums{name,type,picture}");
FacebookData facebookData = JsonConvert.DeserializeObject <FacebookData>(content);
//Select the video groups and photo groups
var mediaGroups = new
{
//Video Groups
videoGroups = facebookData.video_lists.data
.Select(v => new
{
id = v.id,
title = v.title,
thumbnail = v.thumbnail
})
.ToList(),
//Photo Groups
photoGroups = facebookData.albums.data
.Where(p => p.type == "normal")
.Select(p => new
{
id = p.id,
title = p.name,
thumbnail = p.picture.data.url
})
.ToList()
};
if (mediaGroups == null)
{
return(NotFound());
}
return(Ok(mediaGroups));
}
public void AddFacebookNotification(Notification n, FacebookData d)
{
Facebooks.Add(d);
AddGenericNotification(n);
}
