public static async Task <TResult> IdentifyAccountAsync <TResult>(Authorization authorization,
Method authenticationMethod, string externalAccountKey,
IDictionary <string, string> extraParams,
IAzureApplication application,
IProvideLogin loginProvider,
IHttpRequest request,
Func <Guid, IDictionary <string, string>, TResult> onLocated,
Func <Uri, Guid, IDictionary <string, string>, TResult> onInterupted,
Func <string, TResult> onGeneralFailure,
TelemetryClient telemetry)
{
if (!(application is IProvideAccountInformation))
{
authorization.authorized = true;
authorization.LocationAuthentication = null;
// return await OnLegacy();
return(onGeneralFailure($"{application.GetType().FullName} does not implement {nameof(IProvideAccountInformation)}."));
}
var accountInfoProvider = (IProvideAccountInformation)application;
return(await accountInfoProvider.FindOrCreateAccountByMethodAndKeyAsync(
authenticationMethod, externalAccountKey,
authorization, extraParams,
loginProvider, request,
PopulateAccount,
onAccountReady : (internalAccountId, claims) =>
{
return onLocated(internalAccountId, claims);
},
onInterceptProcess : (url, internalAccountId, claims) =>
{
return onInterupted(url, internalAccountId, claims);
},
onReject : onGeneralFailure));
IAccount PopulateAccount(IAccount account)
{
account.AccountLinks = new AccountLinks
{
accountLinks = new AccountLink[]
{
new AccountLink()
{
externalAccountKey = externalAccountKey,
method = authenticationMethod.authenticationId,
}
}
};
if (!(loginProvider is IProvideClaims))
{
return(account);
}
var claimProvider = (IProvideClaims)loginProvider;
var accountPopulatedFromClaims = claimProvider.PopulateResourceFromClaims(account, extraParams);
return(accountPopulatedFromClaims);
}
}
private static Task <Session> Convert(
Security.SessionServer.Persistence.AuthenticationRequest authenticationRequest,
IProvideLogin provider,
Uri loginUrl,
IDictionary <string, string> extraParams,
IDictionary <string, string> labels,
IDictionary <string, Type> types,
IDictionary <string, string> descriptions)
{
return(Convert(authenticationRequest.id, authenticationRequest.method, authenticationRequest.name, provider, authenticationRequest.action, authenticationRequest.token,
authenticationRequest.authorizationId.Value, loginUrl, authenticationRequest.redirect, extraParams, labels, types, descriptions));
}
public static async Task <TResult> AuthorizeWithAccountAsync <TResult>(Authorization authorization,
Func <Authorization, Task> saveAsync,
Method authenticationMethod, string externalAccountKey,
IDictionary <string, string> extraParams,
IAzureApplication application, IHttpRequest request,
IProvideLogin loginProvider,
Uri baseUri,
Func <Guid, Authorization, TResult> onAccountLocated,
Func <Uri, Guid, Authorization, TResult> onInterupted,
Func <string, Authorization, TResult> onGeneralFailure,
TelemetryClient telemetry)
{
return(await await IdentifyAccountAsync(authorization,
authenticationMethod, externalAccountKey, extraParams,
application, loginProvider, request,
onLocated : async(internalAccountId, claims) =>
{
authorization.parameters = extraParams;
authorization.accountIdMaybe = internalAccountId;
authorization.authorized = true;
authorization.claims = claims;
await saveAsync(authorization);
return onAccountLocated(internalAccountId, authorization);
},
onInterupted : async(interceptionUrl, internalAccountId, claims) =>
{
authorization.parameters = extraParams;
authorization.accountIdMaybe = internalAccountId;
authorization.authorized = true;
authorization.claims = claims;
await saveAsync(authorization);
return onInterupted(interceptionUrl, internalAccountId, authorization);
},
onGeneralFailure : async(why) =>
{
// Save params so they can be used later
authorization.parameters = extraParams;
await saveAsync(authorization);
return onGeneralFailure(why, authorization);
},
telemetry : telemetry));
}
private async static Task <Session> Convert(
Guid authenticationRequestStorageId,
string method,
string name,
IProvideLogin provider,
AuthenticationActions action,
string token,
Guid authorizationId,
Uri loginUrl,
Uri redirect,
IDictionary <string, string> extraParams,
IDictionary <string, string> labels,
IDictionary <string, Type> types,
IDictionary <string, string> descriptions)
{
var keys = labels.SelectKeys().Concat(types.SelectKeys()).Concat(descriptions.SelectKeys());
var userParams = keys
.Distinct()
.Select(
key =>
{
var val = default(string);
if (null != extraParams)
{
val = extraParams.ContainsKey(key) ? extraParams[key] : default(string);
}
return((new CustomParameter
{
Value = val,
Type = types.ContainsKey(key) ? types[key] : default(Type),
Label = labels.ContainsKey(key) ? labels[key] : default(string),
Description = descriptions.ContainsKey(key) ? descriptions[key] : default(string),
}).PairWithKey(key));
})
.ToDictionary();
var resourceTypes = await ServiceConfiguration.IntegrationResourceTypesAsync(authenticationRequestStorageId,
(resourceTypesInner) => resourceTypesInner,
() => new string[] { });
var computedName = !string.IsNullOrWhiteSpace(name) ?
name :
provider is IProvideIntegration integrationProvider?integrationProvider.GetDefaultName(extraParams) : method;
return(new Session
{
id = authenticationRequestStorageId,
method = method,
name = computedName,
action = action,
token = token,
authorizationId = authorizationId,
redirectUrl = redirect,
loginUrl = loginUrl,
userParams = userParams,
resourceTypes = resourceTypes
.Select(resourceType => resourceType.PairWithValue(resourceType))
.ToDictionary(),
});
}
public static async Task <TResult> ProcessAsync <TResult>(Authorization authorization,
Func <Authorization, Task> saveAsync,
Method authenticationMethod, string externalAccountKey,
IDictionary <string, string> extraParams,
IAzureApplication application, IHttpRequest request,
IInvokeApplication endpoints, IProvideLogin loginProvider,
Uri baseUri,
Func <Uri, Guid?, Func <IHttpResponse, IHttpResponse>, TResult> onRedirect,
Func <string, TResult> onGeneralFailure,
TelemetryClient telemetry)
{
return(await await AuthorizeWithAccountAsync(
authorization, saveAsync,
authenticationMethod, externalAccountKey, extraParams,
application, request, loginProvider, baseUri,
onAccountLocated : (internalAccountId, authorizationUpdated) =>
{
return CreateLoginResponseAsync(
internalAccountId, extraParams,
authenticationMethod, authorizationUpdated,
application, request, endpoints, baseUri, loginProvider,
(url, modifier) =>
{
// await saveAsync(authorization);
return onRedirect(url, internalAccountId, modifier);
},
(why) =>
{
//await saveAsync(authorization);
return onGeneralFailure(why);
},
telemetry);
},
onInterupted : (interceptionUrl, internalAccountId, authorizationUpdated) =>
{
return onRedirect(interceptionUrl, internalAccountId, m => m).AsTask();
},
onGeneralFailure : (why, authorizationUpdated) =>
{
return onGeneralFailure(why).AsTask();
},
telemetry : telemetry));
}
public static async Task <TResult> ProcessAsync <TResult>(Authorization authorization,
Func <Authorization, Task> saveAsync,
Method authentication, string externalAccountKey,
IDictionary <string, string> extraParams,
Guid requestId, Uri baseUri, AzureApplication application, IProvideLogin loginProvider,
Func <Uri, TResult> onRedirect,
Func <string, TResult> onGeneralFailure,
TelemetryClient telemetry)
{
authorization.authorized = true;
authorization.LocationAuthentication = null;
var result = await await AccountMapping.FindByMethodAndKeyAsync(authentication.authenticationId, externalAccountKey,
authorization,
// Found
async internalAccountId =>
{
authorization.parameters = extraParams;
authorization.accountIdMaybe = internalAccountId;
await saveAsync(authorization);
return(await CreateLoginResponseAsync(requestId,
internalAccountId, extraParams,
authentication, authorization,
baseUri,
application, loginProvider,
onRedirect,
onGeneralFailure,
telemetry));
},
// Not found
async() =>
{
return(await await UnmappedCredentialAsync(externalAccountKey, extraParams,
authentication, authorization,
loginProvider, application, baseUri,
// Create mapping
async(internalAccountId) =>
{
authorization.parameters = extraParams;
authorization.accountIdMaybe = internalAccountId;
await saveAsync(authorization);
return await await AccountMapping.CreateByMethodAndKeyAsync(authorization, externalAccountKey,
internalAccountId,
() =>
{
return CreateLoginResponseAsync(requestId,
internalAccountId, extraParams,
authentication, authorization,
baseUri,
application, loginProvider,
onRedirect,
onGeneralFailure,
telemetry);
},
(why) => onGeneralFailure(why).AsTask());
},
// Allow self serve
async() =>
{
authorization.parameters = extraParams;
await saveAsync(authorization);
return await CreateLoginResponseAsync(requestId,
default(Guid?), extraParams,
authentication, authorization,
baseUri,
application, loginProvider,
onRedirect,
onGeneralFailure,
telemetry);
},
// Intercept process
async(interceptionUrl) =>
{
authorization.parameters = extraParams;
await saveAsync(authorization);
return onRedirect(interceptionUrl);
},
// Failure
async(why) =>
{
// Save params so they can be used later
authorization.parameters = extraParams;
await saveAsync(authorization);
return onGeneralFailure(why);
},
telemetry));
});
return(result);
}
