/// <summary>
/// Extracts the User details accessing the service as a unique id in the form
/// of "{authprovider}:{uniqueId}" using ProviderCrednetials for the logged
/// in user.
/// </summary>
/// <param name="principal">The principal accessing the service.</param>
/// <param name="request">The HttpRequest used to access the service.</param>
/// <returns>The unique user id.</returns>
public async Task <string> GetCurrentUserRegistrationReferenceAsync(ClaimsPrincipal principal, HttpRequestMessage request)
{
string provider = principal?.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider").Value;
ProviderCredentials creds = null;
if (string.Equals(provider, "facebook", StringComparison.OrdinalIgnoreCase))
{
creds = await principal.GetAppServiceIdentityAsync <FacebookCredentials>(request);
}
else if (string.Equals(provider, "google", StringComparison.OrdinalIgnoreCase))
{
creds = await principal.GetAppServiceIdentityAsync <GoogleCredentials>(request);
}
else if (string.Equals(provider, "twitter", StringComparison.OrdinalIgnoreCase))
{
creds = await principal.GetAppServiceIdentityAsync <TwitterCredentials>(request);
}
else if (string.Equals(provider, "microsoftaccount", StringComparison.OrdinalIgnoreCase))
{
creds = await principal.GetAppServiceIdentityAsync <MicrosoftAccountCredentials>(request);
}
if (creds == null)
{
throw ServiceExceptions.UserNullException();
}
// Format user details in the desired form of {authprovider}:{uniqueId}
string authProvider = creds.Provider;
string uniqueId = creds.UserClaims.FirstOrDefault(c => c.Type.Equals(ClaimTypes.NameIdentifier))?.Value;
var uniqueUserName = $"{authProvider}:{uniqueId}";
return(uniqueUserName);
}
private async Task <ProviderCredentials> GetUserCredentials(string provider)
{
ProviderCredentials credentials = null;
switch (provider)
{
case "MicrosoftAccount":
credentials = await this.User.GetAppServiceIdentityAsync <MicrosoftAccountCredentials>(this.Request);
break;
case "Facebook":
credentials = await this.User.GetAppServiceIdentityAsync <FacebookCredentials>(this.Request);
break;
case "Twitter":
credentials = await this.User.GetAppServiceIdentityAsync <TwitterCredentials>(this.Request);
break;
case "Google":
credentials = await this.User.GetAppServiceIdentityAsync <GoogleCredentials>(this.Request);
break;
}
return(credentials);
}
internal static async Task <string> GetUserId(HttpRequestMessage request, IPrincipal user)
{
var principal = user as ClaimsPrincipal;
var claim = principal.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider");
if (claim == null)
{
return(string.Empty);
}
var provider = claim.Value;
ProviderCredentials creds = null;
if (provider.IgnoreCaseEqualsTo("microsoftaccount"))
{
creds = await user.GetAppServiceIdentityAsync <MicrosoftAccountCredentials>(request);
}
else if (provider.IgnoreCaseEqualsTo("facebook"))
{
creds = await user.GetAppServiceIdentityAsync <FacebookCredentials>(request);
}
else if (provider.IgnoreCaseEqualsTo("aad"))
{
creds = await user.GetAppServiceIdentityAsync <AzureActiveDirectoryCredentials>(request);
}
return(creds != null?
string.Format("{0}:{1}", creds.Provider, creds.Claims[ClaimTypes.NameIdentifier]) :
null);
}
internal static async Task <ProviderCredentials> GetCurrentCredentialAsync(HttpRequestMessage request, IPrincipal user)
{
var principal = user as ClaimsPrincipal;
var claim = principal.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider");
if (claim == null)
{
return(null);
}
var provider = claim.Value;
ProviderCredentials creds = null;
if (provider.IgnoreCaseEqualsTo("microsoftaccount"))
{
creds = await user.GetAppServiceIdentityAsync <MicrosoftAccountCredentials>(request);
}
else if (provider.IgnoreCaseEqualsTo("facebook"))
{
creds = await user.GetAppServiceIdentityAsync <FacebookCredentials>(request);
}
else if (provider.IgnoreCaseEqualsTo("aad"))
{
creds = await user.GetAppServiceIdentityAsync <AzureActiveDirectoryCredentials>(request);
}
return(creds);
}
/// <summary>
/// Get Idpuser from Credentials
/// </summary>
/// <returns></returns>
private async Task <string> GetIdpUser()
{
string userName = null;
ClaimsPrincipal principal = User as ClaimsPrincipal;
string provider = principal?.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider").Value;
ProviderCredentials creds = null;
if (string.Equals(provider, "facebook", StringComparison.OrdinalIgnoreCase))
{
creds = await User.GetAppServiceIdentityAsync <FacebookCredentials>(Request);
}
else if (string.Equals(provider, "google", StringComparison.OrdinalIgnoreCase))
{
creds = await User.GetAppServiceIdentityAsync <GoogleCredentials>(Request);
}
else if (string.Equals(provider, "twitter", StringComparison.OrdinalIgnoreCase))
{
creds = await User.GetAppServiceIdentityAsync <TwitterCredentials>(Request);
}
if (creds != null)
{
userName = $"{creds.Provider}:{creds.UserId.ToUpper()}";
}
return(userName);
}
private string GetEmailAddress(ProviderCredentials credentials)
{
return(credentials.UserClaims
.Where(claim => claim.Type.Contains("email"))
.First <Claim>()
.Value);
}
public virtual JwtSecurityToken CreateLoginToken(string secretKey, ClaimsIdentity claimsIdentity, ProviderCredentials providerCredentials)
{
if (string.IsNullOrEmpty(secretKey))
{
throw new ArgumentNullException("secretKey");
}
if (claimsIdentity == null)
{
throw new ArgumentNullException("claimsIdentity");
}
if (providerCredentials == null)
{
throw new ArgumentNullException("providerCredentials");
}
var providerKeyClaim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
if (providerKeyClaim == null)
{
throw new ArgumentException("RResources.Token_Invalid.FormatForUser(claimsIdentity.Name, ClaimTypes.NameIdentifier)");
}
var uid = providerKeyClaim.Value;
var credentialsClaimJson = JsonConvert.SerializeObject(providerCredentials, Formatting.None, this.tokenSerializerSettings);
var claims = new List<Claim>();
claims.Add(new Claim(ProviderCredentialsClaimName, credentialsClaimJson));
claims.Add(new Claim("uid", uid));
claims.Add(new Claim("ver", "1"));
return this.CreateTokenFromClaims(claims, secretKey, ZumoAudienceValue, ZumoIssuerValue);
}
protected virtual async Task InitializeBaseAsync(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
var claimsPrincipal = this.User as ClaimsPrincipal;
mIsAutenticated = claimsPrincipal.Identity.IsAuthenticated;
if (mIsAutenticated)
{
mCredentials = null;
string sid = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;
string provider = claimsPrincipal.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider").Value;
switch (provider.ToLower())
{
case "google":
Task <GoogleCredentials> mAutenticateTask;
mAutenticateTask = User.GetAppServiceIdentityAsync <GoogleCredentials>(controllerContext.Request);
await RunSafe(mAutenticateTask);
if (mAutenticateTask.IsCompleted)
{
mCredentials = mAutenticateTask.Result;
mConnectionInfo = ControllerStatic.GetDBSource(mCredentials);
}
break;
case "microsoftaccount":
Task <MicrosoftAccountCredentials> mAutenticateTaskMicrosoft;
mAutenticateTaskMicrosoft = User.GetAppServiceIdentityAsync <MicrosoftAccountCredentials>(controllerContext.Request);
await RunSafe(mAutenticateTaskMicrosoft);
if (mAutenticateTaskMicrosoft.IsCompleted)
{
mCredentials = mAutenticateTaskMicrosoft.Result;
mConnectionInfo = ControllerStatic.GetDBSource(mCredentials);
}
break;
case "facebook":
Task <FacebookCredentials> mAutenticateTaskFacebook;
mAutenticateTaskFacebook = User.GetAppServiceIdentityAsync <FacebookCredentials>(controllerContext.Request);
await RunSafe(mAutenticateTaskFacebook);
if (mAutenticateTaskFacebook.IsCompleted)
{
mCredentials = mAutenticateTaskFacebook.Result;
mConnectionInfo = ControllerStatic.GetDBSource(mCredentials);
}
break;
default:
break;
}
}
}
public ProviderCredentialsTests()
{
this.credsMock = new Mock <ProviderCredentials>("TestProvider")
{
CallBase = true
};
this.creds = this.credsMock.Object;
}
public async Task DeleteOwnProvidersCredentials([FromBody] ProviderCredentials providerCredentials, CancellationToken cancellationToken)
{
var isDeleted = await _accountProvidersManager.DeleteAccountProviderCredentials(User.Identity?.Name, providerCredentials, cancellationToken);
if (!isDeleted)
{
throw new ArgumentException("Could not delete the account provider");
}
}
public async Task SetOwnProvidersCredentials([FromBody] ProviderCredentials providerCredentials, CancellationToken cancellationToken)
{
if (providerCredentials.Email != User.Identity?.Name)
{
throw new ArgumentException("Account email is not your own");
}
await _accountProvidersManager.SetAccountProviderCredentials(User.Identity?.Name, providerCredentials.Password, providerCredentials, cancellationToken);
}
public static string FindFirstValue(this ProviderCredentials principal, string claimType)
{
if (principal == null)
{
throw new ArgumentNullException(nameof(principal));
}
var claim = principal.UserClaims.FirstOrDefault(c => c.Type == claimType);
return(!(string.IsNullOrWhiteSpace(claim.Value)) ? claim.Value : null);
}
public static async Task <T> GetAppServiceIdentityAsync <T>(this IPrincipal principal, HttpRequestMessage request, HttpClient httpClient) where T : ProviderCredentials, new()
{
if (request == null)
{
throw new ArgumentNullException("request");
}
ClaimsPrincipal user = principal as ClaimsPrincipal;
if (user == null)
{
throw new ArgumentOutOfRangeException(RResources.ParameterMustBeOfType.FormatInvariant("principal", typeof(ClaimsPrincipal).Name), (Exception)null);
}
// Get the token from the request
string zumoAuthToken = request.GetHeaderOrDefault("x-zumo-auth");
if (string.IsNullOrEmpty(zumoAuthToken))
{
return(null);
}
// Base the url on the issuer of the JWT
Claim issuerClaim = user.FindFirst(JwtRegisteredClaimNames.Iss);
if (issuerClaim == null)
{
throw new ArgumentOutOfRangeException(RResources.GetIdentity_ClaimsMustHaveIssuer, (Exception)null);
}
string issuerUrl = issuerClaim.Value;
ProviderCredentials credentials = (ProviderCredentials) new T();
TokenEntry tokenEntry = null;
AppServiceHttpClient appSvcClient = new AppServiceHttpClient(httpClient);
try
{
tokenEntry = await appSvcClient.GetRawTokenAsync(new Uri(issuerUrl), zumoAuthToken, credentials.Provider);
}
catch (HttpResponseException ex)
{
throw new InvalidOperationException(RResources.GetIdentity_HttpError.FormatInvariant(ex.Response.ToString()));
}
if (!IsTokenValid(tokenEntry))
{
return(null);
}
PopulateProviderCredentials(tokenEntry, credentials);
return((T)credentials);
}
public async Task SetLastSuccessfulUpdate(string identity, ProviderCredentials providerCredentials, DateTimeOffset dateTimeOffset, CancellationToken cancellationToken)
{
Guard.Argument(identity).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials).NotNull();
Guard.Argument(providerCredentials.ProviderName, nameof(providerCredentials.ProviderName)).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials.Email, nameof(providerCredentials.Email)).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials.ProviderUserName, nameof(providerCredentials.ProviderUserName)).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials.ProviderUserPassword, nameof(providerCredentials.ProviderUserPassword)).NotNull().NotWhiteSpace();
providerCredentials.LastSuccessfulUpdate = dateTimeOffset;
await _accountProvidersSetMap.AddItemAsync(identity, providerCredentials, cancellationToken);
}
public async Task <IHttpActionResult> GetFoodTruck()
{
ClaimsPrincipal userClaims = User as ClaimsPrincipal;
string provider = userClaims.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider").Value;
string sid = userClaims.FindFirst("stable_sid").Value;
ProviderCredentials creds = await this.User.GetAppServiceIdentityAsync <TwitterCredentials>(this.Request);
var userAuthType = User.Identity.AuthenticationType;
var user = creds.UserClaims;
return(Ok(provider));
}
public static async Task <string> FindSidAsync(IPrincipal claimsPrincipal, HttpRequestMessage request)
{
var aiTelemetry = new TelemetryClient();
var principal = claimsPrincipal as ClaimsPrincipal;
if (principal == null)
{
aiTelemetry.TrackEvent("FindSidAsync: ClaimsPrincipal is null!");
return(string.Empty);
}
var match = principal.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider");
string provider;
if (match != null)
{
provider = match.Value;
}
else
{
aiTelemetry.TrackEvent("FindSidAsync: Can't find identity provider");
return(string.Empty);
}
ProviderCredentials creds = null;
if (string.Equals(provider, "facebook", StringComparison.OrdinalIgnoreCase))
{
creds = await claimsPrincipal.GetAppServiceIdentityAsync <FacebookCredentials>(request);
}
else if (string.Equals(provider, "microsoftaccount", StringComparison.OrdinalIgnoreCase))
{
creds = await claimsPrincipal.GetAppServiceIdentityAsync <MicrosoftAccountCredentials>(request);
}
else if (string.Equals(provider, "twitter", StringComparison.OrdinalIgnoreCase))
{
creds = await claimsPrincipal.GetAppServiceIdentityAsync <TwitterCredentials>(request);
}
if (creds == null)
{
aiTelemetry.TrackEvent("FindSidAsync: Credentials not found");
return(string.Empty);
}
var finalId = $"{creds.Provider}:{creds.UserClaims.First(c => c.Type == ClaimTypes.NameIdentifier).Value}";
return(finalId);
}
public static ConnectionInfo GetDBSource(ProviderCredentials credentials)
{
DBData db = new DBData("mxeqxlr2h5.database.windows.net,1433", "orderEntryDB", "TrilogikSa", "Password.1");
StringBuilder sql = new StringBuilder();
sql.Append("SELECT a.servername, a.dbname, a.dbuser, a.dbpassword, a.devicemail, IsNull(a.idagente, 0) as idagente, IsNull(a.superuser, 0) as superuser ");
sql.Append("FROM [orderEntry].[Autenticate] a ");
sql.AppendFormat("WHERE a.devicemail = '{0}' ", credentials.UserId);
DataTable dt = null;
string deviceMail = "";
int idAgente = 0;
try
{
dt = db.ReadData(sql.ToString());
DBData dbAgente = new DBData("mxeqxlr2h5.database.windows.net,1433", "LamandeDB", "TrilogikSa", "Password.1");
string sqlAgente = "SELECT DeviceMail, IdAgente FROM DEVICE_ParametriDevice WHERE DeviceMail = '" + credentials.UserId + "'";
DataTable dtAgente = dbAgente.ReadData(sqlAgente);
if (dtAgente.Rows.Count > 0)
{
deviceMail = (string)dtAgente.Rows[0]["DeviceMail"];
idAgente = (int)dtAgente.Rows[0]["IdAgente"];
}
}
catch (System.Exception ex)
{
throw ex;
}
ConnectionInfo connectionInfo = new ConnectionInfo();
if (dt.Rows.Count > 0)
{
connectionInfo.ServerName = (string)dt.Rows[0]["servername"];
connectionInfo.DBName = (string)dt.Rows[0]["dbname"];
connectionInfo.DBUser = (string)dt.Rows[0]["dbuser"];
connectionInfo.DBPassword = (string)dt.Rows[0]["dbpassword"];
connectionInfo.DeviceMail = deviceMail;
connectionInfo.IdAgente = idAgente;
connectionInfo.SuperUser = (bool)dt.Rows[0]["superuser"];
}
return(connectionInfo);
}
public async Task <bool> FetchProviderAssets(ProviderCredentials accountProvider, string password, string code, CancellationToken cancellationToken)
{
var providerUserName = _encryptorManager.Decrypt(accountProvider.ProviderUserName, password);
var providerUserPassword = _encryptorManager.Decrypt(accountProvider.ProviderUserPassword, password);
try
{
var provider = _providerFactory.GetProvider(accountProvider.ProviderName);
var isLoginSuccessful = await provider.LoginAsync(providerUserName, providerUserPassword, code, cancellationToken);
if (!isLoginSuccessful)
{
return(false);
}
var assets = await provider.GetAssetsAsync(cancellationToken);
var dateTimeNow = DateTimeOffset.UtcNow;
if (accountProvider.LastSuccessfulUpdate.Date == dateTimeNow.Date)
{
var sameDayAssets = await GetCurrentAssetsForProviderAsync(accountProvider.Email, accountProvider, cancellationToken);
var deleteAssetsTasks =
sameDayAssets.Select(a => DeleteAssetAsync(accountProvider.Email, a, cancellationToken));
await Task.WhenAll(deleteAssetsTasks);
}
var saveAssetsTask = assets.Select(a =>
{
a.StorageDate = dateTimeNow;
return(SetAssetAsync(accountProvider.Email, a, cancellationToken));
});
await Task.WhenAll(saveAssetsTask);
await _accountProvidersManager.SetLastSuccessfulUpdate(accountProvider.Email, accountProvider, dateTimeNow, cancellationToken);
return(true);
}
catch (Exception)
{
return(false);
}
}
internal static async Task <string> GetUserId(HttpRequestMessage request, IPrincipal user)
{
ClaimsPrincipal principal = user as ClaimsPrincipal;
string provider = principal.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider").Value;
ProviderCredentials creds = null;
if (string.Equals(provider, "facebook", StringComparison.OrdinalIgnoreCase))
{
creds = await user.GetAppServiceIdentityAsync <FacebookCredentials>(request);
}
else if (string.Equals(provider, "aad", StringComparison.OrdinalIgnoreCase))
{
creds = await user.GetAppServiceIdentityAsync <AzureActiveDirectoryCredentials>(request);
}
return(creds != null?
string.Format("{0}:{1}", creds.Provider, creds.Claims[ClaimTypes.NameIdentifier]) :
null);
}
/// <summary>
/// Attempts to pull user details from provider to set initial defaults.
/// </summary>
/// <param name="claimant"></param>
/// <param name="volunteer"></param>
private async Task FillProviderDetails(ClaimsIdentity claimant, Volunteer volunteer)
{
ProviderCredentials creds = null;
// Try to get details from provider
switch (claimant.FindFirst(identityProvider)?.Value)
{
case "google":
Trace.TraceInformation("Trying to get Google profile info...");
creds = await this.User.GetAppServiceIdentityAsync <GoogleCredentials>(this.Request);
break;
case "microsoftaccount":
Trace.TraceInformation("Trying to get Microsoft profile info...");
creds = await this.User.GetAppServiceIdentityAsync <MicrosoftAccountCredentials>(this.Request);
break;
}
// Use claims in ProviderCredentials
if (creds != null && creds.UserClaims.Any())
{
volunteer.FirstName = volunteer.FirstName ?? creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.GivenName)?.Value;
volunteer.LastName = volunteer.LastName ?? creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.Surname)?.Value;
volunteer.Email = creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.Email)?.Value;
volunteer.MobilePhone = creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.MobilePhone)?.Value ?? volunteer.MobilePhone;
volunteer.HomePhone = volunteer.HomePhone ?? creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.HomePhone)?.Value;
volunteer.Address.Street = volunteer.Address.Street ?? creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.StreetAddress)?.Value;
volunteer.Address.City = volunteer.Address.City ?? creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.Locality)?.Value;
volunteer.Address.State = volunteer.Address.State ?? creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.StateOrProvince)?.Value;
volunteer.Address.ZipCode = volunteer.Address.ZipCode ?? creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.PostalCode)?.Value;
Trace.TraceInformation($"Volunteer profile (Provider): {volunteer.Email}, {volunteer.LastName}, {volunteer.FirstName}, {volunteer.MobilePhone}, {volunteer.HomePhone}");
Trace.TraceInformation($" {volunteer.Address.Street}, {volunteer.Address.City}, {volunteer.Address.State} {volunteer.Address.ZipCode}");
}
}
public virtual JwtSecurityToken CreateLoginToken(string secretKey, ClaimsIdentity claimsIdentity, ProviderCredentials providerCredentials)
{
if (string.IsNullOrEmpty(secretKey))
{
throw new ArgumentNullException("secretKey");
}
if (claimsIdentity == null)
{
throw new ArgumentNullException("claimsIdentity");
}
if (providerCredentials == null)
{
throw new ArgumentNullException("providerCredentials");
}
var providerKeyClaim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
if (providerKeyClaim == null)
{
throw new ArgumentException("RResources.Token_Invalid.FormatForUser(claimsIdentity.Name, ClaimTypes.NameIdentifier)");
}
var uid = providerKeyClaim.Value;
var credentialsClaimJson = JsonConvert.SerializeObject(providerCredentials, Formatting.None, this.tokenSerializerSettings);
var claims = new List <Claim>();
claims.Add(new Claim(ProviderCredentialsClaimName, credentialsClaimJson));
claims.Add(new Claim("uid", uid));
claims.Add(new Claim("ver", "1"));
return(this.CreateTokenFromClaims(claims, secretKey, ZumoAudienceValue, ZumoIssuerValue));
}
public async Task <bool> DeleteAccountProviderCredentials(string identity, ProviderCredentials providerCredentials, CancellationToken cancellationToken)
{
Guard.Argument(identity).NotNull().NotEmpty();
return(await _accountProvidersSetMap.TryRemoveItemAsync(identity, providerCredentials, cancellationToken));
}
public async Task SetAccountProviderCredentials(string identity, string password, ProviderCredentials providerCredentials, CancellationToken cancellationToken)
{
Guard.Argument(identity).NotNull().NotWhiteSpace();
Guard.Argument(password).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials).NotNull();
Guard.Argument(providerCredentials.ProviderName, nameof(providerCredentials.ProviderName)).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials.Email, nameof(providerCredentials.Email)).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials.ProviderUserName, nameof(providerCredentials.ProviderUserName)).NotNull().NotWhiteSpace();
Guard.Argument(providerCredentials.ProviderUserPassword, nameof(providerCredentials.ProviderUserPassword)).NotNull().NotWhiteSpace();
providerCredentials.ProviderUserName = _encryptorManager.Encrypt(providerCredentials.ProviderUserName, password);
providerCredentials.ProviderUserPassword = _encryptorManager.Encrypt(providerCredentials.ProviderUserPassword, password);
await _accountProvidersSetMap.AddItemAsync(identity, providerCredentials, cancellationToken);
if (providerCredentials.ShouldCachePassword)
{
var encryptedPassword = _encryptorManager.Encrypt(password, _configurations.SymmetricKey);
await _passwordMap.TryAddAsync(identity, encryptedPassword, true, cancellationToken);
}
}
internal static void PopulateProviderCredentials(TokenEntry tokenEntry, ProviderCredentials credentials)
{
if (tokenEntry.UserClaims != null)
{
Collection <Claim> userClaims = new Collection <Claim>();
foreach (ClaimSlim claim in tokenEntry.UserClaims)
{
userClaims.Add(new Claim(claim.Type, claim.Value));
}
credentials.UserClaims = userClaims;
}
FacebookCredentials facebookCredentials = credentials as FacebookCredentials;
if (facebookCredentials != null)
{
facebookCredentials.AccessToken = tokenEntry.AccessToken;
facebookCredentials.UserId = tokenEntry.UserId;
return;
}
GoogleCredentials googleCredentials = credentials as GoogleCredentials;
if (googleCredentials != null)
{
googleCredentials.AccessToken = tokenEntry.AccessToken;
googleCredentials.RefreshToken = tokenEntry.RefreshToken;
googleCredentials.UserId = tokenEntry.UserId;
googleCredentials.AccessTokenExpiration = tokenEntry.ExpiresOn;
return;
}
AzureActiveDirectoryCredentials aadCredentials = credentials as AzureActiveDirectoryCredentials;
if (aadCredentials != null)
{
aadCredentials.AccessToken = tokenEntry.IdToken;
Claim objectIdClaim = credentials.UserClaims.FirstOrDefault(c => string.Equals(c.Type, ObjectIdentifierClaimType, StringComparison.OrdinalIgnoreCase));
if (objectIdClaim != null)
{
aadCredentials.ObjectId = objectIdClaim.Value;
}
Claim tenantIdClaim = credentials.UserClaims.FirstOrDefault(c => string.Equals(c.Type, TenantIdClaimType, StringComparison.OrdinalIgnoreCase));
if (tenantIdClaim != null)
{
aadCredentials.TenantId = tenantIdClaim.Value;
}
aadCredentials.UserId = tokenEntry.UserId;
return;
}
MicrosoftAccountCredentials microsoftAccountCredentials = credentials as MicrosoftAccountCredentials;
if (microsoftAccountCredentials != null)
{
microsoftAccountCredentials.AccessToken = tokenEntry.AccessToken;
microsoftAccountCredentials.RefreshToken = tokenEntry.RefreshToken;
microsoftAccountCredentials.UserId = tokenEntry.UserId;
microsoftAccountCredentials.AccessTokenExpiration = tokenEntry.ExpiresOn;
return;
}
TwitterCredentials twitterCredentials = credentials as TwitterCredentials;
if (twitterCredentials != null)
{
twitterCredentials.AccessToken = tokenEntry.AccessToken;
twitterCredentials.AccessTokenSecret = tokenEntry.AccessTokenSecret;
twitterCredentials.UserId = tokenEntry.UserId;
return;
}
}
internal static void PopulateProviderCredentials(TokenEntry tokenEntry, ProviderCredentials credentials)
{
if (tokenEntry.UserClaims != null)
{
credentials.Claims = new Dictionary <string, string>();
foreach (ClaimSlim claim in tokenEntry.UserClaims)
{
credentials.Claims[claim.Type] = claim.Value;
}
}
FacebookCredentials facebookCredentials = credentials as FacebookCredentials;
if (facebookCredentials != null)
{
facebookCredentials.AccessToken = tokenEntry.AccessToken;
facebookCredentials.UserId = tokenEntry.UserId;
return;
}
GoogleCredentials googleCredentials = credentials as GoogleCredentials;
if (googleCredentials != null)
{
googleCredentials.AccessToken = tokenEntry.AccessToken;
googleCredentials.RefreshToken = tokenEntry.RefreshToken;
googleCredentials.UserId = tokenEntry.UserId;
googleCredentials.AccessTokenExpiration = tokenEntry.ExpiresOn;
return;
}
AzureActiveDirectoryCredentials aadCredentials = credentials as AzureActiveDirectoryCredentials;
if (aadCredentials != null)
{
aadCredentials.AccessToken = tokenEntry.IdToken;
aadCredentials.ObjectId = credentials.Claims.GetValueOrDefault(ObjectIdentifierClaimType);
aadCredentials.TenantId = credentials.Claims.GetValueOrDefault(TenantIdClaimType);
aadCredentials.UserId = tokenEntry.UserId;
return;
}
MicrosoftAccountCredentials microsoftAccountCredentials = credentials as MicrosoftAccountCredentials;
if (microsoftAccountCredentials != null)
{
microsoftAccountCredentials.AccessToken = tokenEntry.AccessToken;
microsoftAccountCredentials.RefreshToken = tokenEntry.RefreshToken;
microsoftAccountCredentials.UserId = tokenEntry.UserId;
microsoftAccountCredentials.AccessTokenExpiration = tokenEntry.ExpiresOn;
return;
}
TwitterCredentials twitterCredentials = credentials as TwitterCredentials;
if (twitterCredentials != null)
{
twitterCredentials.AccessToken = tokenEntry.AccessToken;
twitterCredentials.AccessTokenSecret = tokenEntry.AccessTokenSecret;
twitterCredentials.UserId = tokenEntry.UserId;
return;
}
}
