private void DoTwitterLogin(HttpContext context, string returnUrl)
{
if (TwitterConsumer.IsTwitterConsumerConfigured)
{
var token = context.Request["oauth_token"];
if (string.IsNullOrEmpty(token))
{
var request = TwitterConsumer.StartSignInWithTwitter(false);
request.Send();
}
else
{
string screenName;
int userId;
string accessToken;
if (TwitterConsumer.TryFinishSignInWithTwitter(out screenName, out userId, out accessToken))
{
//Sucess. Get information
var info = TwitterConsumer.GetUserInfo(userId, accessToken);
var profile = UniversalProfile.ProfileFromTwitter(info);
RedirectToReturnUrl(context, returnUrl, profile);
}
else
{
RedirectToReturnUrl(context, returnUrl, UniversalProfile.FromError(new Exception("Login failed")));
}
}
}
}
private void DoFacebookLogin(HttpContext context, string returnUrl)
{
var client = new FacebookClient
{
ClientIdentifier = ConfigurationManager.AppSettings["facebookAppID"],
ClientSecret = ConfigurationManager.AppSettings["facebookAppSecret"],
};
IAuthorizationState authorization = client.ProcessUserAuthorization(null);
if (authorization == null)
{
// Kick off authorization request
var scope = new List <string>()
{
"email,user_about_me",
};
client.RequestUserAuthorization(scope, null, null);
}
else
{
var request = WebRequest.Create("https://graph.facebook.com/me?access_token=" + Uri.EscapeDataString(authorization.AccessToken));
using (var response = request.GetResponse())
{
if (response != null)
{
using (var responseStream = response.GetResponseStream())
{
var graph = FacebookGraph.Deserialize(responseStream);
var profile = UniversalProfile.ProfileFromFacebook(graph);
RedirectToReturnUrl(context, returnUrl, profile);
}
}
}
}
}
public IEnumerable <UniversalProfile> GetLinkedProfiles(string obj)
{
//Retrieve by uinque id
using (var db = new DbManager(DbId))
{
var query = new SqlQuery(LinkTable)
.Select("profile").Where("id", obj);
return(db.ExecuteList(query, (x) => UniversalProfile.CreateFromSerializedString((string)x[0])));
}
}
public IEnumerable <string> GetLinkedObjects(UniversalProfile profile)
{
//Retrieve by uinque id
using (var db = new DbManager(DbId))
{
var query = new SqlQuery(LinkTable)
.Select("id").Where("uid", profile.HashId);
return(db.ExecuteList(query, (x) => (string)x[0]));
}
}
public void RemoveLink(string obj, UniversalProfile profile)
{
using (var db = new DbManager(DbId))
{
using (var tx = db.BeginTransaction())
{
db.ExecuteScalar <int>(
new SqlDelete(LinkTable)
.Where("id", obj)
.Where("uid", profile.HashId)
);
tx.Commit();
}
}
}
public void AddLink(string obj, UniversalProfile profile)
{
using (var db = new DbManager(DbId))
{
using (var tx = db.BeginTransaction())
{
db.ExecuteScalar <int>(
new SqlInsert(LinkTable)
.InColumnValue("id", obj)
.InColumnValue("uid", profile.HashId)
.InColumnValue("provider", profile.Provider)
.InColumnValue("profile", profile.ToSerializedString())
.InColumnValue("linked", DateTime.Now)
);
tx.Commit();
}
}
}
public void ProcessRequest(HttpContext context)
{
var returnUrl = context.Request["returnurl"] ?? FormsAuthentication.LoginUrl;
var auth = context.Request["auth"];
if (!string.IsNullOrEmpty(auth))
{
try
{
switch (auth)
{
case "twitter":
DoTwitterLogin(context, returnUrl);
break;
case "facebook":
DoFacebookLogin(context, returnUrl);
break;
default:
DoOpenIdLogin(context, returnUrl);
break;
}
}
catch (ThreadAbortException)
{
//Thats is responce ending
}
catch (Exception ex)
{
RedirectToReturnUrl(context, returnUrl, UniversalProfile.FromError(ex));
}
}
else
{
//Render xrds
var xrdsloginuri = new Uri(context.Request.GetUrlRewriter(),
new Uri(context.Request.GetUrlRewriter().AbsolutePath, UriKind.Relative)).ToString() + "?auth=openid&returnurl=" + returnUrl;
var xrdsimageuri = new Uri(context.Request.GetUrlRewriter(),
new Uri(context.Request.ApplicationPath, UriKind.Relative)).ToString() + "openid.gif";
XrdsHelper.RenderXrds(context.Response, xrdsloginuri, xrdsimageuri);
}
}
private void DoOpenIdLogin(HttpContext context, string returnUrl)
{
var response = Openid.GetResponse();
if (response == null)
{
Identifier id;
if (Identifier.TryParse(context.Request["openid_identifier"], out id))
{
try
{
var request = Openid.CreateRequest(context.Request["openid_identifier"]);
request.AddExtension(new ClaimsRequest
{
Email = DemandLevel.Require,
Nickname = DemandLevel.Require,
Country = DemandLevel.Request,
Gender = DemandLevel.Request,
PostalCode = DemandLevel.Request,
TimeZone = DemandLevel.Request,
FullName = DemandLevel.Request,
});
var fetch = new FetchRequest();
fetch.Attributes.AddRequired(WellKnownAttributes.Contact.Email);
//Duplicating attributes
//fetch.Attributes.AddRequired("http://schema.openid.net/contact/email");//Add two more
//fetch.Attributes.AddRequired("http://openid.net/schema/contact/email");
fetch.Attributes.AddRequired(WellKnownAttributes.Name.Alias);
fetch.Attributes.AddRequired(WellKnownAttributes.Name.First);
fetch.Attributes.AddRequired(WellKnownAttributes.Name.Last);
fetch.Attributes.AddRequired(WellKnownAttributes.Name.Middle);
fetch.Attributes.AddRequired(WellKnownAttributes.Person.Gender);
fetch.Attributes.AddRequired(WellKnownAttributes.BirthDate.WholeBirthDate);
fetch.Attributes.AddRequired(WellKnownAttributes.Media.Images.Default);
request.AddExtension(fetch);
request.RedirectToProvider();
}
catch (ProtocolException ex)
{
RedirectToReturnUrl(context, returnUrl, UniversalProfile.FromError(ex));
}
}
else
{
RedirectToReturnUrl(context, returnUrl, UniversalProfile.FromError(new Exception("invalid OpenID identifier")));
}
}
else
{
// Stage 3: OpenID Provider sending assertion response
switch (response.Status)
{
case AuthenticationStatus.Authenticated:
var spprofile = response.GetExtension <ClaimsResponse>();
var fetchprofile = response.GetExtension <FetchResponse>();
var profile = UniversalProfile.ProfileFromOpenId(spprofile, fetchprofile, response.ClaimedIdentifier.ToString());
if (!string.IsNullOrEmpty(returnUrl))
{
RedirectToReturnUrl(context, returnUrl, profile);
}
break;
case AuthenticationStatus.Canceled:
RedirectToReturnUrl(context, returnUrl, UniversalProfile.FromError(new Exception("Canceled at provider")));
break;
case AuthenticationStatus.Failed:
RedirectToReturnUrl(context, returnUrl, UniversalProfile.FromError(response.Exception));
break;
}
}
}
private static void RedirectToReturnUrl(HttpContext context, string returnUrl, UniversalProfile profile)
{
if (context.Session != null)
{
//Store in session
context.Response.Redirect(new Uri(returnUrl, UriKind.Absolute).AddProfileSession(profile, context).ToString(), true);
}
else if (HttpRuntime.Cache != null)
{
context.Response.Redirect(new Uri(returnUrl, UriKind.Absolute).AddProfileCache(profile).ToString(), true);
}
else
{
context.Response.Redirect(new Uri(returnUrl, UriKind.Absolute).AddProfile(profile).ToString(), true);
}
}
