public async Task <TResult> CreatedAuthenticationLogoutAsync <TResult>(Guid requestId,
AzureApplication application,
string reason, string method,
IProvideAuthorization provider, IDictionary <string, string> extraParams, Uri redirectUrl,
Func <Task <TResult> > onContinue,
Func <string, TResult> onStop)
{
var loggingTask = CredentialProcessDocument.UpdateAsync(requestId,
async(doc, saveAsync) =>
{
doc.Message = "LOGOUT";
doc.Action = Enum.GetName(typeof(AuthenticationActions), AuthenticationActions.signin);
doc.Provider = provider.GetType().FullName;
doc.SetValuesCredential(extraParams);
doc.RedirectUrl = redirectUrl.IsDefaultOrNull() ? string.Empty : redirectUrl.ToString();
await saveAsync(doc);
return(true);
},
application.AzureContext.DataContext.AzureStorageRepository);
var resp = await onContinue();
bool b = await loggingTask;
return(resp);
}
public Task <TResult> CredentialUnmappedAsync <TResult>(Guid requestId,
AzureApplication application,
string subject, string method,
IProvideAuthorization credentialProvider, IDictionary <string, string> extraParams,
Func <Guid,
Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > >,
Func <string, Task <TResult> >,
Task <Task <TResult> > > createMappingAsync,
Func <
Func <Guid,
Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > >,
Func <string, Task <TResult> >,
Task <Task <TResult> > >,
Task <TResult> > onContinue,
Func <string, TResult> onStop)
{
return(CredentialProcessDocument.UpdateAsync(requestId,
async(doc, saveAsync) =>
{
doc.Message = "CREDENTIAL LOOKUP NOT FOUND";
doc.Provider = credentialProvider.GetType().FullName;
doc.SetValuesCredential(extraParams);
await saveAsync(doc);
Func <Guid,
Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > >,
Func <string, Task <TResult> >,
Task <Task <TResult> > > createMappingWrappedAsync =
async(authorizationId, onCreated, onFailure) =>
{
doc.AuthorizationId = authorizationId;
Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > > onCreateWrapped =
async(sessionId, token, refreshToken, action, redirectUrl) =>
{
doc.Message = "LOOKUP CREATED";
doc.SessionId = sessionId;
doc.Token = token;
doc.RefreshToken = refreshToken;
doc.Action = Enum.GetName(typeof(AuthenticationActions), action);
doc.RedirectUrl = redirectUrl.IsDefaultOrNull() ? string.Empty : redirectUrl.ToString();
await saveAsync(doc);
return await onCreated(sessionId, token, refreshToken, action, redirectUrl);
};
Func <string, Task <TResult> > onFailureWrapped =
async(why) =>
{
doc.Message = $"LOOKUP CREATION FAILURE:{why}";
await saveAsync(doc);
return await onFailure(why);
};
return await createMappingAsync(authorizationId, onCreateWrapped, onFailureWrapped);
};
var resp = await onContinue(createMappingWrappedAsync);
return resp;
},
application.AzureContext.DataContext.AzureStorageRepository));
}
public Task <TResult> CredentialUnmappedAsync <TResult>(Guid requestId, AzureApplication application, string subject, string method,
IProvideAuthorization credentialProvider, IDictionary <string, string> extraParams,
Func <Guid, Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > >,
Func <string, Task <TResult> >, Task <Task <TResult> > > createMappingAsync,
Func <Func <Guid, Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > >,
Func <string, Task <TResult> >, Task <Task <TResult> > >, Task <TResult> > onContinue,
Func <string, TResult> onStop)
{
return(onContinue(createMappingAsync));
}
public Task <TResult> CreatedAuthenticationLogoutAsync <TResult>(AzureApplication application,
string reason, string method,
IProvideAuthorization provider, IDictionary <string, string> extraParams, Uri redirectUrl,
Func <Task <TResult> > onContinue,
Func <string, TResult> onStop)
{
//await saveAuthLogAsync(true, $"Logout:{location} -- {reason}", extraParams);
application.Telemetry.TrackEvent($"ResponseController.ProcessRequestAsync - location: {redirectUrl.AbsolutePath}");
return(onContinue());
}
public async Task <TResult> TokenRedeemedAsync <TResult>(string method, IProvideAuthorization provider,
string subject, Guid?stateId, Guid?loginId, IDictionary <string, string> extraParamsWithRedemptionParams,
Func <Guid, Guid, string, string, AuthenticationActions, IProvideAuthorization, IDictionary <string, string>, Uri, TResult> onLogin,
Func <Uri, string, IProvideAuthorization, IDictionary <string, string>, TResult> onLogout,
LookupCredentialNotFoundDelegate <TResult> lookupCredentialNotFound,
Func <string, TResult> onInvalidToken,
Func <string, TResult> onNotConfigured,
Func <string, TResult> onFailure,
TelemetryClient telemetry)
{
telemetry.TrackEvent("Sessions.CreateOrUpdateWithAuthenticationAsync: Authenticated", extraParamsWithRedemptionParams);
// This is the case where the login process started from an existing authentication resource
if (stateId.HasValue)
{
telemetry.TrackEvent($"Sessions.CreateOrUpdateWithAuthenticationAsync: StateId: {stateId.Value.ToString()}");
return(await AuthenticateStateAsync(stateId.Value, loginId, method, subject, extraParamsWithRedemptionParams,
(authorizationId, authenticationId, token, refreshToken, action, extraParamsAuthenticated, redirectUrl) =>
onLogin(authorizationId, authenticationId, token, refreshToken, action, provider, extraParamsAuthenticated, redirectUrl),
(redirectUrl, reason, extraParamsAuthenticated) => onLogout(redirectUrl, reason, provider, extraParamsAuthenticated),
onInvalidToken,
onNotConfigured,
onFailure));
}
// This is the case where the login process started from an external system
telemetry.TrackEvent("StateId not found. Starting external system login flow.");
return(await await dataContext.CredentialMappings.LookupCredentialMappingAsync(method, subject, loginId,
(authenticationId) =>
{
telemetry.TrackEvent($"Sessions.CreateOrUpdateWithAuthenticationAsync: Called from external login system. AuthenticationId: {authenticationId.ToString()}");
var authorizationId = Guid.NewGuid();
return this.CreateLoginAsync(authorizationId, authenticationId, method, default(Uri), extraParamsWithRedemptionParams,
(session) => onLogin(authorizationId, authenticationId, session.token, session.refreshToken, AuthenticationActions.signin, provider, session.extraParams,
default(Uri)),
"Guid not unique for creating authentication started from external system".AsFunctionException <TResult>(),
onFailure);
},
() => lookupCredentialNotFound(subject, provider, extraParamsWithRedemptionParams,
async(authenticationId, onCreatedLogin, onFailureToCreateLogin) =>
{
var sessionId = Guid.NewGuid();
var authorizationId = sessionId;
return await await dataContext.CredentialMappings.CreateCredentialMappingAsync <Task <TResult> >(
sessionId, method, subject, authenticationId,
async() =>
{
return await await this.CreateLoginAsync <Task <TResult> >(authorizationId, authenticationId, method, default(Uri), extraParamsWithRedemptionParams,
(session) => onCreatedLogin(sessionId, session.token, session.refreshToken, AuthenticationActions.signin, session.redirectUrl),
"Guid not unique for creating authentication started from external system".AsFunctionException <Task <TResult> >(),
onFailureToCreateLogin.AsAsyncFunc());
},
() => "Guid not unique for creating authentication started from external system".AsFunctionException <Task <TResult> >()(),
() => onFailureToCreateLogin("Token is already in use.").ToTask());
})));
}
public async Task <TResult> CredentialUnmappedAsync <TResult>(AzureApplication application,
string subject, string method,
IProvideAuthorization credentialProvider, IDictionary <string, string> extraParams,
Func <Guid, Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > >,
Func <string, Task <TResult> >, Task <Task <TResult> > > createMappingAsync,
Func <TResult> onContinue,
Func <string, TResult> onStop)
{
application.Telemetry.TrackEvent($"ResponseController.ProcessRequestAsync - Token is not connected to a user in this system.");
//var updatingAuthLogTask = saveAuthLogAsync(true, $"Login:{subject}/{credentialProvider.GetType().FullName}", extraParams);
return(onContinue());
}
public static async Task <TResult> UnmappedCredentailAsync <TResult>(AzureApplication application,
IProvideAuthorization authorizationProvider, string method, string subject, IDictionary <string, string> extraParams,
Uri baseUri,
Func <Guid,
Func <Guid, string, string, AuthenticationActions, Uri, Task <Task <TResult> > >,
Func <string, Task <TResult> >, Task <Task <TResult> > > createMappingAsync,
Func <Uri, string, TResult> onRedirect,
Func <HttpStatusCode, string, string, TResult> onResponse,
TelemetryClient telemetry)
{
throw new NotImplementedException();
//return await await application.OnUnmappedUserAsync<Task<TResult>>(method, authorizationProvider, subject, extraParams,
// async (authorizationId) =>
// {
// //await updatingAuthLogTask;
// telemetry.TrackEvent($"ResponseController.ProcessRequestAsync - Creating Authentication.");
// //updatingAuthLogTask = saveAuthLogAsync(true, $"New user mapping requested:{subject}/{credentialProvider.GetType().FullName}[{authorizationId}]", extraParams);
// return await await createMappingAsync(authorizationId,
// async (sessionId, jwtToken, refreshToken, action, redirectUrl) =>
// {
// //await updatingAuthLogTask;
// //await saveAuthLogAsync(true, $"New user mapping requested:{subject}/{credentialProvider.GetType().FullName}[{authorizationId}]", extraParams);
// telemetry.TrackEvent($"ResponseController.ProcessRequestAsync - Created Authentication. Creating response.");
// var resp = CreateResponse(application, authorizationProvider, method, action,
// sessionId, authorizationId, jwtToken, refreshToken, extraParams,
// baseUri, redirectUrl,
// onRedirect,
// onResponse,
// telemetry);
// //await updatingAuthLogTask;
// return resp;
// },
// async (why) =>
// {
// //await updatingAuthLogTask;
// //await saveAuthLogAsync(true, $"Failure to create user mapping requested:{subject}/{credentialProvider.GetType().FullName}[{authorizationId}]: {why}", extraParams);
// var message = $"Failure to connect token to a user in this system: {why}";
// telemetry.TrackException(new ResponseException(message));
// return onResponse(HttpStatusCode.Conflict, message, message);
// });
// },
// () =>
// {
// var message = "Token is not connected to a user in this system";
// telemetry.TrackException(new ResponseException(message));
// return onResponse(HttpStatusCode.Conflict, message, message).ToTask();
// });
}
//public static async Task<TResult> LegacyAccountMappingAsync<TResult>(Authorization authorization,
// Method authenticationMethod, string externalAccountKey,
// IDictionary<string, string> extraParams,
// IAzureApplication application,
// IProvideLogin loginProvider,
// Uri baseUri,
// Func<Guid, Func<bool, Task<TResult>>, TResult> onLocated,
// Func<Guid, TResult> onCreated,
// Func<TResult> onSelfServe,
// Func<Uri, TResult> onInterupted,
// Func<string, TResult> onGeneralFailure,
// TelemetryClient telemetry)
//{
// return await await AccountMapping.FindByMethodAndKeyAsync(
// authenticationMethod.authenticationId, externalAccountKey,
// authorization,
// // Found
// internalAccountId =>
// {
// return onLocated(
// internalAccountId,
// (isAccountInvalid) => OnNotFound(isAccountInvalid))
// .AsTask();
// },
// () => OnNotFound(false));
// async Task<TResult> OnNotFound(bool isAccountInvalid)
// {
// return await await UnmappedCredentialAsync(externalAccountKey, extraParams,
// authenticationMethod, authorization,
// loginProvider, application, baseUri,
// // Create mapping
// (internalAccountId) =>
// {
// return AccountMapping.CreateByMethodAndKeyAsync(
// authorization, externalAccountKey, internalAccountId,
// () =>
// {
// return onCreated(internalAccountId);
// },
// () =>
// {
// return onLocated(internalAccountId, default);
// },
// isAccountInvalid);
// },
// // Allow self serve
// () =>
// {
// return onSelfServe().AsTask();
// },
// // Intercept process
// (interceptionUrl) =>
// {
// return onInterupted(interceptionUrl).AsTask();
// },
// // Failure
// (why) =>
// {
// return onGeneralFailure(why).AsTask();
// },
// telemetry);
// }
//}
private static Task <TResult> CreateLoginResponseAsync <TResult>(
Guid?accountId, IDictionary <string, string> extraParams,
Method method, Authorization authorization,
IAuthApplication application,
IHttpRequest request, IInvokeApplication endpoints,
Uri baseUrl,
IProvideAuthorization authorizationProvider,
Func <Uri, Func <IHttpResponse, IHttpResponse>, TResult> onRedirect,
Func <string, TResult> onBadResponse,
TelemetryClient telemetry)
{
return(application.GetRedirectUriAsync(
accountId, extraParams,
method, authorization,
request, endpoints,
baseUrl,
authorizationProvider,
(redirectUrlSelected, modifier) =>
{
telemetry.TrackEvent($"CreateResponse - redirectUrlSelected1: {redirectUrlSelected.AbsolutePath}");
telemetry.TrackEvent($"CreateResponse - redirectUrlSelected2: {redirectUrlSelected.AbsoluteUri}");
return onRedirect(redirectUrlSelected, modifier);
},
(paramName, why) =>
{
var message = $"Invalid parameter while completing login: {paramName} - {why}";
telemetry.TrackException(new ResponseException(message));
return onBadResponse(message);
},
() =>
{
var message = $"Invalid account while completing login";
telemetry.TrackException(new ResponseException(message));
return onBadResponse(message);
},
(why) =>
{
var message = $"General failure while completing login: {why}";
telemetry.TrackException(new ResponseException(message));
return onBadResponse(message);
}));
}
public virtual async Task <TResult> OnUnmappedUserAsync <TResult>(
string subject, IDictionary <string, string> extraParameters,
EastFive.Azure.Auth.Method authentication, EastFive.Azure.Auth.Authorization authorization,
IProvideAuthorization authorizationProvider, Uri baseUri,
Func <Guid, TResult> onCreatedMapping,
Func <TResult> onAllowSelfServeAccounts,
Func <Uri, TResult> onInterceptProcess,
Func <TResult> onNoChange)
{
if (authorizationProvider is Credentials.IProvideAccountInformation)
{
var accountInfoProvider = authorizationProvider as Credentials.IProvideAccountInformation;
return(await accountInfoProvider
.CreateAccount(subject, extraParameters,
authentication, authorization, baseUri,
this,
onCreatedMapping,
onAllowSelfServeAccounts,
onInterceptProcess,
onNoChange));
}
return(onNoChange());
}
private static Task <TResult> UnmappedCredentialAsync <TResult>(
string subject, IDictionary <string, string> extraParams,
EastFive.Azure.Auth.Method authentication, Authorization authorization,
IProvideAuthorization authorizationProvider,
AzureApplication application,
Uri baseUri,
Func <Guid, TResult> createMapping,
Func <TResult> onAllowSelfServe,
Func <Uri, TResult> onInterceptProcess,
Func <string, TResult> onFailure,
TelemetryClient telemetry)
{
return(application.OnUnmappedUserAsync(subject, extraParams,
authentication, authorization, authorizationProvider, baseUri,
(accountId) => createMapping(accountId),
() => onAllowSelfServe(),
(callback) => onInterceptProcess(callback),
() =>
{
var message = "Token is not connected to a user in this system";
telemetry.TrackException(new ResponseException(message));
return onFailure(message);
}));
}
public static async Task <TResult> CreateResponse <TResult>(AzureApplication application, IProvideAuthorization authorizationProvider,
string method, AuthenticationActions action,
Guid sessionId, Guid?authorizationId, string jwtToken, string refreshToken,
IDictionary <string, string> extraParams, Uri baseUri, Uri redirectUrl,
Func <Uri, string, TResult> onRedirect,
Func <HttpStatusCode, string, string, TResult> onResponse,
TelemetryClient telemetry)
{
throw new NotImplementedException();
//var redirectResponse = await application.GetRedirectUriAsync(authorizationProvider,
// method, action,
// sessionId, authorizationId, jwtToken, refreshToken, extraParams,
// baseUri,
// redirectUrl,
// (redirectUrlSelected) =>
// {
// telemetry.TrackEvent($"CreateResponse - redirectUrlSelected1: {redirectUrlSelected.AbsolutePath}");
// telemetry.TrackEvent($"CreateResponse - redirectUrlSelected2: {redirectUrlSelected.AbsoluteUri}");
// return onRedirect(redirectUrlSelected, null);
// },
// (paramName, why) =>
// {
// var message = $"Invalid parameter while completing login: {paramName} - {why}";
// telemetry.TrackException(new ResponseException(message));
// return onResponse(HttpStatusCode.BadRequest, message, why);
// },
// (why) =>
// {
// var message = $"General failure while completing login: {why}";
// telemetry.TrackException(new ResponseException(message));
// return onResponse(HttpStatusCode.BadRequest, message, why);
// });
//var msg = redirectResponse;
//telemetry.TrackEvent($"CreateResponse - {msg}");
//return redirectResponse;
}
public Task <TResult> CreatedAuthenticationLogoutAsync <TResult>(Guid requestId, AzureApplication application, string reason, string method, IProvideAuthorization provider, IDictionary <string, string> extraParams, Uri redirectUrl, Func <Task <TResult> > onContinue, Func <string, TResult> onStop)
{
return(onContinue());
}
public Task <TResult> CreatedAuthenticationLoginAsync <TResult>(Guid requestId, AzureApplication application, Guid sessionId, Guid authorizationId, string token, string refreshToken, string method, AuthenticationActions action, IProvideAuthorization provider, IDictionary <string, string> extraParams, Uri redirectUrl, Func <Task <TResult> > onContinue, Func <string, TResult> onStop)
{
return(onContinue());
}
public async Task <TResult> CreatedAuthenticationLoginAsync <TResult>(AzureApplication application,
Guid sessionId, Guid authorizationId,
string token, string refreshToken,
string method, AuthenticationActions action, IProvideAuthorization provider,
IDictionary <string, string> extraParams, Uri redirectUrl,
Func <Task <TResult> > onContinue,
Func <string, TResult> onStop)
{
//var updatingAuthLogTask = saveAuthLogAsync(true, $"Login:{authorizationId}/{sessionId}[{action}]", extraParams);
application.Telemetry.TrackEvent($"ResponseController.ProcessRequestAsync - Created Authentication. Creating response.");
var resp = onContinue();
//await updatingAuthLogTask;
return(await resp);
}
