public override IClaimsIdentity ProcessSignInResponse(string realm, string originalUrl, HttpContextBase httpContext)
{
var client = new MicrosoftClient(this.appId, this.secretKey);
AuthenticationResult result;
try
{
result = client.VerifyAuthentication(httpContext, this.MultiProtocolIssuer.ReplyUrl);
}
catch (WebException wex)
{
throw new InvalidOperationException(new StreamReader(wex.Response.GetResponseStream()).ReadToEnd(), wex);
}
var claims = new List <Claim>
{
new Claim(System.IdentityModel.Claims.ClaimTypes.NameIdentifier, result.ExtraData["id"])
};
foreach (var claim in result.ExtraData)
{
claims.Add(new Claim("http://schemas.live.com/" + claim.Key, claim.Value));
}
return(new ClaimsIdentity(claims, "LiveId"));
}
public static void RegisterAuth()
{
if (OpenAuth.AuthenticationClients.GetByProviderName("microsoft") == null)
{
MicrosoftClient msClient = new MicrosoftClient("a8f83bd5-dd71-4f7b-a56b-295a5a1a0334", ".Xm4NgH873~rGMoMvCz.21pNsSEp0~.QnD");
OpenAuth.AuthenticationClients.Add("microsoft", () => msClient);
}
}
public MicrosoftOAuthClient(string clientId, string clientSecretId, string requestScopes)
{
Check.IsNotNull(clientId, "ClientId");
Check.IsNotNull(clientSecretId, "ClientSecretId");
if (requestScopes != null && requestScopes.Count() <= 0)
{
this.client = new MicrosoftClient(clientId, clientSecretId);
}
else
{
var scopes = requestScopes.Split(',');
this.client = new MicrosoftClient(clientId, clientSecretId, scopes);
}
}
private async void Microsoft_Click(object sender, RoutedEventArgs e)
{
viewModel.IsButtonAvailable = false;
viewModel.IsLoading = true;
try
{
var token = new MicrosoftToken();
await token.AcquireNewToken();
var msClient = new MicrosoftClient(token);
AppGlobalVariables.Users.Add(await msClient.GetUserDataAsync());
}
catch (Exception ex)
{
DebugHelper.Debugger.WriteErrorLog("Error in acquiring MS token on AuthDialog.", ex);
}
dialogHost.Hide();
}
private async Task <List <Models.Common.EventBase> > GetMicrosoftEvents(DateTime datetime, Models.Auth.UserBase user)
{
var events = new List <Models.Common.EventBase>();
var msClient = new MicrosoftClient(user);
if (user.Calendars.Count == 0)
{
var calendars = await msClient.GetCalendarList();
var calCache = new CalendarCacheHelper();
await calCache.Init();
foreach (var calendar in calendars.value)
{
calCache.CheckIfEnabled(calendar);
}
user.Calendars.AddRange(calendars.value);
}
if (user.Calendars.Count > 0)
{
foreach (var calendar in user.Calendars)
{
if (calendar.IsEnabled)
{
try
{
var msevents = await msClient.GetEventList(calendar, datetime);
events.AddRange(msevents.value);
}
catch (Exception ex)
{
Debugger.WriteErrorLog("Error occured while retrieving Microsoft Events. User="******". Calendar=" + calendar.Name + ".", ex);
await new MessageDialog(ex.Message + ". User="******". Calendar=" + calendar.Name + ". Please consider excluding this calendar.", "Error occured while retrieving Microsoft Events.").ShowAsync();
}
}
}
}
return(events);
}
public static async Task <UserBase> AcquireUserFromToken(TokenBase token)
{
try
{
switch (token.UserType)
{
case UserType.Google:
var googleClient = new GoogleClient(token);
return(await googleClient.GetUserDataAsync());
case UserType.Microsoft:
var msClient = new MicrosoftClient(token);
return(await msClient.GetUserDataAsync());
case UserType.NatureRemo:
var remoClient = new NatureRemoClient(token);
return(await remoClient.GetUserDataAsync());
case UserType.Hue:
return(await HueAuthClient.FindHueBridge(token));
default:
break;
}
}
catch (Exception ex)
{
Debugger.WriteErrorLog("Exception occured on acquiring user info. Type=" + token.UserType.ToString(), ex);
//var message = new MessageDialog("Type=" + token.UserType.ToString() + " Exception=" + ex.Message, "Exception occured on acquiring user info.");
//await message.ShowAsync();
var user = new UserBase();
user.Token = token;
user.UserType = token.UserType;
user.UserName = "******";
user.ProfilePictureUrl = "/Assets/Square150x150Logo.scale-200.png";
user.Id = token.Id;
return(user);
}
return(null);
}
public static ExtendedMicrosoftClientUserData GetExtraData(this MicrosoftClient client, string accessToken)
{
ExtendedMicrosoftClientUserData graph;
var request =
WebRequest.Create(
"https://apis.live.net/v5.0/me?access_token=" + EscapeUriDataStringRfc3986(accessToken));
using (var response = request.GetResponse())
{
using (var responseStream = response.GetResponseStream())
{
using (StreamReader sr = new StreamReader(responseStream))
{
string data = sr.ReadToEnd();
graph = JsonConvert.DeserializeObject <ExtendedMicrosoftClientUserData>(data);
}
}
}
return(graph);
}
public override void ProcessSignInRequest(Scope scope, HttpContextBase httpContext)
{
var client = new MicrosoftClient(this.appId, this.secretKey);
client.RequestAuthentication(httpContext, this.MultiProtocolIssuer.ReplyUrl);
}
public ActionResult ExternalLoginCallback(string returnUrl)
{
string ProviderName = OpenAuth.GetProviderNameFromCurrentRequest();
if (ProviderName == null || ProviderName == "")
{
NameValueCollection nvs = Request.QueryString;
if (nvs.Count > 0)
{
if (nvs["state"] != null)
{
NameValueCollection provideritem = HttpUtility.ParseQueryString(nvs["state"]);
if (provideritem["microsoft"] != null)
{
ProviderName = provideritem["microsoft"];
}
}
}
}
var redirectUrl = Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl }, this.Request.Url.Scheme);
if (ProviderName == null)
{
ProviderName = "microsoft";
}
MicrosoftClient msClient = OpenAuth.AuthenticationClients.GetByProviderName(ProviderName) as MicrosoftClient;
var authResult = msClient.VerifyAuthentication(new HttpContextWrapper(HttpContext.ApplicationInstance.Context), new Uri(redirectUrl));
if (!authResult.IsSuccessful)
{
return(Redirect(Url.Action("Login", "Account")));
}
// User has logged in with provider successfully
// Check if user is already registered locally
if (OpenAuth.Login(authResult.Provider, authResult.ProviderUserId, createPersistentCookie: false))
{
return(Redirect(Url.Action("Index", "Home")));
}
//Get provider user details
string ProviderUserId = authResult.ProviderUserId;
string ProviderUserName = authResult.UserName;
string FirstName = null;
string LastName = null;
string Email = null;
if (FirstName == null && authResult.ExtraData.ContainsKey("firstname"))
{
FirstName = authResult.ExtraData["firstname"];
}
if (LastName == null && authResult.ExtraData.ContainsKey("lastname"))
{
LastName = authResult.ExtraData["lastname"];
}
// call extension method to get email
ExtendedMicrosoftClientUserData data = msClient.GetExtraData(authResult.ExtraData["accesstoken"]);
Email = data.Emails.Preferred;
if (User.Identity.IsAuthenticated)
{
// User is already authenticated, add the external login and redirect to return url
OpenAuth.AddAccountToExistingUser(ProviderName, ProviderUserId, ProviderUserName, User.Identity.Name);
return(Redirect(Url.Action("Index", "Home")));
}
else
{
// User is new, save email as username
string membershipUserName = Email ?? ProviderUserId;
var createResult = OpenAuth.CreateUser(ProviderName, ProviderUserId, ProviderUserName, membershipUserName);
if (!createResult.IsSuccessful)
{
ViewBag.Message = "User cannot be created";
return(View());
}
else
{
// User created
if (OpenAuth.Login(ProviderName, ProviderUserId, createPersistentCookie: false))
{
return(Redirect(Url.Action("Index", "Home")));
}
}
}
return(View());
}