public async static Task <IHttpResponse> GetByIdAsync(
[QueryParameter(Name = IntegrationIdPropertyName)] IRef <XIntegration> integrationRef,
IAuthApplication application, SessionToken security,
ContentTypeResponse <XIntegration> onFound,
NotFoundResponse onNotFound,
UnauthorizedResponse onUnauthorized)
{
if (!security.accountIdMaybe.HasValue)
{
return(onUnauthorized());
}
var accountId = security.accountIdMaybe.Value;
return(await await integrationRef.StorageGetAsync(
integration =>
{
return Auth.Method.ById(integration.Method,
application,
method =>
{
integration.methodName = method.name;
return onFound(integration);
},
() => onNotFound());
},
() => onNotFound().AsTask()));
}
public static async Task <IHttpResponse> GetAsync(
[QueryParameter(Name = SessionIdPropertyName, CheckFileName = true)] IRef <Session> sessionRef,
EastFive.Api.SessionTokenMaybe security,
IAuthApplication application,
ContentTypeResponse <Session> onFound,
NotFoundResponse onNotFound,
UnauthorizedResponse onUnauthorized,
ConfigurationFailureResponse onConfigurationFailure)
{
if (!IsAnonSessionAllowed())
{
if (security.sessionId != sessionRef.id)
{
return(onUnauthorized());
}
}
return(await await sessionRef.StorageGetAsync(
(session) =>
{
return Web.Configuration.Settings.GetUri(
EastFive.Security.AppSettings.TokenScope,
scope =>
{
return Web.Configuration.Settings.GetDouble(Security.SessionServer.Configuration.AppSettings.TokenExpirationInMinutes,
(tokenExpirationInMinutes) =>
{
return GetClaimsAsync(application, session.authorization,
(claims, accountIdMaybe, authorized) =>
{
session.account = accountIdMaybe;
session.authorized = authorized;
return Api.Auth.JwtTools.CreateToken(session.id,
scope, TimeSpan.FromMinutes(tokenExpirationInMinutes), claims,
(tokenNew) =>
{
session.token = tokenNew;
return onFound(session);
},
(missingConfig) => onConfigurationFailure("Missing", missingConfig),
(configName, issue) => onConfigurationFailure(configName, issue));
},
(why) => onNotFound());
},
(why) => onConfigurationFailure("Missing", why).AsTask());
},
(why) => onConfigurationFailure("Missing", why).AsTask());
},
() => onNotFound().AsTask()));
bool IsAnonSessionAllowed()
{
var appType = application.GetType();
if (!appType.TryGetAttributeInterface <IConfigureAuthorization>(out IConfigureAuthorization authConfig))
{
return(false);
}
return(authConfig.IsAnonymousSessionAllowed);
}
}
public async static Task <IHttpResponse> GetByAccountAsync(
[QueryParameter(Name = AccountPropertyName)] Guid accountId,
IAuthApplication application, SessionToken security,
MultipartAsyncResponse <XIntegration> onContents,
UnauthorizedResponse onUnauthorized)
{
if (!await application.CanAdministerCredentialAsync(accountId, security))
{
return(onUnauthorized());
}
var integrations = GetIntegrationsByAccount(accountId)
.Select(
kvp =>
{
var integration = kvp.Key;
return(Auth.Method.ById(kvp.Value.Method,
application,
method =>
{
integration.methodName = method.name;
return integration;
},
() => default(XIntegration?)));
})
.Await()
.SelectWhereHasValue();
return(onContents(integrations));
}
[Api.HttpGet] //(MatchAllBodyParameters = false)]
public static async Task <IHttpResponse> GetAsync(
EastFive.Api.SessionToken security,
IHttpRequest request,
IAuthApplication application,
[WorkflowVariable("Session", SessionPropertyName)]
[WorkflowVariable2("Account", AccountPropertyName)]
ContentTypeResponse <Whoami> onFound)
{
async Task <string> GetName()
{
if (!security.accountIdMaybe.HasValue)
{
return(string.Empty);
}
return(await application.GetActorNameDetailsAsync(security.accountIdMaybe.Value,
(first, last, email) =>
{
return $"{first} {last} [{email}]";
},
() => string.Empty));
}
request.TryParseJwt(out System.IdentityModel.Tokens.Jwt.JwtSecurityToken securityToken);
var whoami = new Whoami()
{
session = security.sessionId.AsRef <Session>(),
account = security.accountIdMaybe,
name = await GetName(),
securityToken = securityToken,
};
return(onFound(whoami));
}
public static Task <IHttpResponse> QueryBySessionAsync(
[QueryParameter(Name = "session")] IRef <Session> sessionRef,
IAuthApplication application,
MultipartAsyncResponse <Method> onContent,
ReferencedDocumentNotFoundResponse <Session> onSessionNotFound,
UnauthorizedResponse onHacked)
{
return(sessionRef.StorageGetAsync(
session =>
{
var integrationProviders = application.LoginProviders
.Where(loginProvider => loginProvider.Value.GetType().IsSubClassOfGeneric(typeof(IProvideSession)))
.Select(
async loginProvider =>
{
var supportsIntegration = await(loginProvider.Value as IProvideSession).SupportsSessionAsync(session);
return supportsIntegration.PairWithValue(loginProvider);
})
.AsyncEnumerable()
.Where(kvp => kvp.Key)
.SelectValues()
.Select(
(loginProvider) =>
{
return new Method
{
authenticationId = new Ref <Method>(loginProvider.Value.Id),
name = loginProvider.Value.Method,
};
});
return onContent(integrationProviders);
},
//() => onSessionNotFound().AsTask());
() => onHacked()));
}
public static IHttpResponse GetByMethodAsync(
[QueryParameter(Name = Authorization.MethodPropertyName)] IRef <Method> methodRef,
IAuthApplication application, SessionToken security,
MultipartAsyncResponse <XIntegration> onContents,
UnauthorizedResponse onUnauthorized)
{
if (!security.accountIdMaybe.HasValue)
{
return(onUnauthorized());
}
var accountId = security.accountIdMaybe.Value;
var integrations = GetIntegrationsByAccount(accountId)
.Where(integration => integration.Value.Method.id == methodRef.id)
.Select(
kvp =>
{
var integration = kvp.Key;
return(Auth.Method.ById(kvp.Value.Method,
application,
method =>
{
integration.methodName = method.name;
return integration;
},
() => default(XIntegration?)));
})
.Await()
.SelectWhereHasValue();
return(onContents(integrations));
}
public Task <TResult> GetLoginProviderAsync <TResult>(IAuthApplication application,
Func <string, IProvideLogin, TResult> onFound,
Func <TResult> onNotFound)
{
return(GetLoginProvider(this.id, application,
onFound,
onNotFound).AsTask());
}
public async static Task <IHttpResponse> CreateAsync(
[Property(Name = AccountPropertyName)] Guid accountId,
[Property(Name = AuthorizationPropertyName)] IRef <Authorization> authorizationRef,
[Resource] AccountMapping accountMapping,
IAuthApplication application, Api.SessionToken security,
CreatedResponse onCreated,
ForbiddenResponse onForbidden,
UnauthorizedResponse onUnauthorized,
ReferencedDocumentDoesNotExistsResponse <Authorization> onAuthenticationDoesNotExist,
GeneralConflictResponse onFailure)
{
if (!await application.CanAdministerCredentialAsync(accountId, security))
{
return(onUnauthorized());
}
return(await await authorizationRef.StorageGetAsync(
async authorization =>
{
accountMapping.Method = authorization.Method; // method is used in the .mappingId
var authorizationLookup = new AuthorizationLookup
{
accountMappingRef = accountMapping.mappingId,
authorizationLookupRef = authorizationRef,
};
return await await authorizationLookup.StorageCreateAsync(
async(idDiscard) =>
{
accountMapping.accountMappingLookup = await await authorization.ParseCredentailParameters(
application,
(accountKey, loginProvider) =>
{
var lookup = new AccountMappingLookup()
{
accountkey = accountKey,
accountMappingId = accountMapping.mappingId,
Method = authorization.Method,
};
return lookup.StorageCreateAsync(
(discard) => new RefOptional <AccountMappingLookup>(
lookup.accountMappingLookupId),
() => new RefOptional <AccountMappingLookup>());
},
(why) =>
{
var amLookupMaybe = new RefOptional <AccountMappingLookup>();
return amLookupMaybe.AsTask();
});
return await accountMapping.StorageCreateAsync(
createdId =>
{
return onCreated();
},
() => onForbidden().AddReason("Account is already mapped to that authentication."));
},
() => onFailure("Authorization is already mapped to another account.").AsTask());
},
() => onAuthenticationDoesNotExist().AsTask()));
}
public static Task <IHttpResponse> QueryByIdAsync(
[QueryId] IRef <Method> methodRef,
IAuthApplication application,
ContentTypeResponse <Method> onFound,
NotFoundResponse onNotFound)
{
return(ById(methodRef, application,
method => onFound(method),
() => onNotFound()));
}
public AuthController(
IUserApplication userApplication,
IAuthApplication authApplication,
ITokenApplication tokenApplication,
IMapper mapper)
{
this._authApplication = authApplication;
this._userApplication = userApplication;
this._tokenApplication = tokenApplication;
this._mapper = mapper;
}
public Task <TResult> GetAuthorizationKeyAsync <TResult>(IAuthApplication application,
IDictionary <string, string> parameters,
Func <string, TResult> onAuthorizeKey,
Func <string, TResult> onFailure,
Func <TResult> loginMethodNoLongerSupported)
{
return(GetLoginProviderAsync(application,
(name, loginProvider) => loginProvider.ParseCredentailParameters(parameters,
(externalUserKey, authenticationIdMaybe, scopeMaybeDiscard) => onAuthorizeKey(externalUserKey),
why => onFailure(why)),
() => loginMethodNoLongerSupported()));
}
public static async Task <IHttpResponse> GetAsync(
//[WorkflowNewId]
//[WorkflowVariable(
// Workflows.PasswordLoginCreateAccount.Variables.State,
// AuthorizationPropertyName)]
[OptionalQueryParameter(Name = AuthorizationPropertyName)]
IRefOptional <Authorization> authorizationRefOptional,
[WorkflowParameter(
Value = "d989b604-1e25-4d77-b79e-fe1c7d36f833",
Description = "Unique and static to each client (i.e. iOS or Web)")]
[QueryParameter(Name = ClientPropertyName)]
IRef <Client> clientRef,
[WorkflowNewId(Description = "No idea what this does.")]
[OptionalQueryParameter(Name = ValidationPropertyName)]
string validation,
IAuthApplication application, IProvideUrl urlHelper,
//ContentTypeResponse<Authentication> onFound,
[WorkflowVariable(
Workflows.PasswordLoginCreateAccount.Variables.Authorization,
Authentication.AuthenticationPropertyName)]
[WorkflowVariableRedirectUrl(
VariableName = Workflows.PasswordLoginCreateAccount.Variables.AuthorizationRedirect)]
RedirectResponse onFound,
ReferencedDocumentNotFoundResponse <Client> onInvalidClient)
{
return(await await clientRef.StorageGetAsync(
(client) =>
{
var authentication = new Authentication
{
authenticationRef = SecureGuid.Generate().AsRef <Authentication>(),
authorizationMaybe = authorizationRefOptional,
client = clientRef,
};
return authentication.StorageCreateAsync(
(entity) =>
{
var location = urlHelper.GetLocation <Authentication>(
auth => auth.authenticationRef.AssignQueryValue(authentication.authenticationRef),
application);
return onFound(location);
});
},
() => onInvalidClient().AsTask()));
}
internal Task <Uri> GetLogoutUrlAsync(IAuthApplication application,
IProvideUrl urlHelper, Guid authorizationIdSecure)
{
var authenticationId = this.id;
return(GetLoginProviderAsync(application,
(name, loginProvider) =>
{
var redirectionResource = loginProvider.CallbackController;
var redirectionLocation = urlHelper.GetLocation(redirectionResource);
return loginProvider.GetLogoutUrl(authorizationIdSecure, redirectionLocation,
type => urlHelper.GetLocation(type));
},
() => throw new Exception($"Login provider with id {authenticationId} does not exists.")));
}
public static Method ByMethodName(string methodName, IAuthApplication application)
{
return(application.LoginProviders
.SelectValues()
.Where(loginProvider => loginProvider.Method == methodName)
.First <IProvideLogin, Method>(
(loginProvider, next) =>
{
return new Method
{
authenticationId = new Ref <Method>(loginProvider.Id),
name = loginProvider.Method,
};
},
() => throw new Exception($"Login provider `{methodName}` is not enabled.")));
}
public static Task <TResult> ById <TResult>(IRef <Method> method, IAuthApplication application,
Func <Method, TResult> onFound,
Func <TResult> onNotFound)
{
return(GetLoginProvider(method.id, application,
(key, loginProvider) =>
{
var authentication = new Method
{
authenticationId = new Ref <Method>(loginProvider.Id),
name = loginProvider.Method,
};
return onFound(authentication);
},
onNotFound).AsTask());
}
public static IHttpResponse AllAsync(
[QueryParameter(Name = "start_time")] DateTime startTime,
[QueryParameter(Name = "end_time")] DateTime endTime,
RequestMessage <Authorization> authorizations,
IAuthApplication application,
EastFive.Api.SessionToken?securityMaybe,
MultipartAsyncResponse <Login> onFound)
{
var methodLookups = application.LoginProviders
.Select(
(loginProvider) =>
{
return(loginProvider.Value.Id.PairWithValue(loginProvider.Value.Method));
})
.ToDictionary();
var results = authorizations
.Where(auth => auth.lastModified <= endTime)
.Where(auth => auth.lastModified >= startTime)
.StorageGet()
.Take(100)
.Select(
async auth =>
{
var name = auth.accountIdMaybe.HasValue ?
await application.GetActorNameDetailsAsync(auth.accountIdMaybe.Value,
(a, b, c) => $"{a} {b}",
() => "")
:
"";
return(new Login()
{
actorId = auth.accountIdMaybe,
authorization = auth.authorizationRef,
name = name,
method = methodLookups.ContainsKey(auth.Method.id) ?
methodLookups[auth.Method.id]
:
auth.Method.id.ToString(),
when = auth.lastModified,
});
})
.Await();
return(onFound(results));
}
public static IHttpResponse QueryAsync(
IAuthApplication application,
[WorkflowVariableResourceResponse]
MultipartAcceptArrayResponse <Method> onContent)
{
var methods = application.LoginProviders
.Select(
(loginProvider) =>
{
return(new Method
{
authenticationId = loginProvider.Value.Id.AsRef <Method>(),
name = loginProvider.Value.Method,
});
});
return(onContent(methods));
}
public static Task <IHttpResponse> UpdateBodyAsync(
[UpdateId(Name = SessionIdPropertyName)] IRef <Session> sessionRef,
[PropertyOptional(Name = AuthorizationPropertyName)] IRefOptional <Authorization> authorizationRefMaybe,
IAuthApplication application,
ContentTypeResponse <Session> onUpdated,
NotFoundResponse onNotFound,
ForbiddenResponse forbidden,
ConfigurationFailureResponse onConfigurationFailure,
GeneralConflictResponse onFailure)
{
return(sessionRef.StorageUpdateAsync(
(sessionStorage, saveSessionAsync) =>
{
return Security.AppSettings.TokenScope.ConfigurationUri(
scope =>
{
return Security.SessionServer.Configuration.AppSettings.TokenExpirationInMinutes.ConfigurationDouble(
async(tokenExpirationInMinutes) =>
{
return await await GetClaimsAsync(application, authorizationRefMaybe,
async(claims, accountIdMaybe, authorized) =>
{
sessionStorage.authorization = authorizationRefMaybe;
sessionStorage.authorized = authorized;
sessionStorage.account = accountIdMaybe;
return await Api.Auth.JwtTools.CreateToken(sessionRef.id,
scope, TimeSpan.FromMinutes(tokenExpirationInMinutes), claims,
async(tokenNew) =>
{
sessionStorage.token = tokenNew;
await saveSessionAsync(sessionStorage);
return onUpdated(sessionStorage);
},
(missingConfig) => onConfigurationFailure("Missing", missingConfig).AsTask(),
(configName, issue) => onConfigurationFailure(configName, issue).AsTask());
},
why => onFailure(why).AsTask());
},
why => onConfigurationFailure("Missing", why).AsTask());
},
(why) => onConfigurationFailure("Missing", why).AsTask());
},
onNotFound: () => onNotFound()));
}
public static Task <IHttpResponse> GetByRequestIdAsync(
[QueryParameter(Name = SessionIdPropertyName, CheckFileName = true)] IRef <Session> sessionRef,
[QueryParameter(Name = EastFive.Api.Azure.AzureApplication.QueryRequestIdentfier)] IRef <Authorization> authorization,
//EastFive.Api.SessionToken security,
IAuthApplication application, IProvideUrl urlHelper,
ContentTypeResponse <Session> onUpdated,
NotFoundResponse onNotFound,
ForbiddenResponse forbidden,
ConfigurationFailureResponse onConfigurationFailure,
GeneralConflictResponse onFailure)
{
return(UpdateBodyAsync(sessionRef, authorization.Optional(),
application,
onUpdated,
onNotFound,
forbidden,
onConfigurationFailure,
onFailure));
}
//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 static async Task <IHttpResponse> QueryByIntegrationAsync(
[QueryParameter(Name = "integration")] IRef <XIntegration> integrationRef,
IAuthApplication application, EastFive.Api.SessionToken security,
MultipartAsyncResponse <Method> onContent,
UnauthorizedResponse onUnauthorized,
ReferencedDocumentNotFoundResponse <XIntegration> onIntegrationNotFound)
{
return(await await integrationRef.StorageGetAsync(
async (integration) =>
{
var accountId = integration.accountId;
if (!await application.CanAdministerCredentialAsync(accountId, security))
{
return onUnauthorized();
}
var integrationProviders = application.LoginProviders
.Where(loginProvider => loginProvider.Value.GetType().IsSubClassOfGeneric(typeof(IProvideIntegration)))
.Select(
async loginProvider =>
{
var integrationProvider = loginProvider.Value as IProvideIntegration;
var supportsIntegration = await integrationProvider.SupportsIntegrationAsync(accountId);
return supportsIntegration.PairWithValue(loginProvider);
})
.AsyncEnumerable()
.Where(kvp => kvp.Key)
.SelectValues()
.Select(
(loginProvider) =>
{
var integrationProvider = loginProvider.Value as IProvideIntegration;
return new Method
{
authenticationId = new Ref <Method>(loginProvider.Value.Id),
name = integrationProvider.GetDefaultName(new Dictionary <string, string>()),
};
});
return onContent(integrationProviders);
},
() => onIntegrationNotFound().AsTask()));
}
private static TResult GetLoginProvider <TResult>(Guid authenticationId, IAuthApplication application,
Func <string, IProvideLogin, TResult> onFound,
Func <TResult> onNotFound)
{
//var debug = application.LoginProviders.ToArrayAsync().Result;
return(application.LoginProviders
.Where(
loginProvider =>
{
return loginProvider.Value.Id == authenticationId;
})
.First(
(loginProviderKvp, next) =>
{
var loginProviderKey = loginProviderKvp.Key;
var loginProvider = loginProviderKvp.Value;
return onFound(loginProviderKey, loginProvider);
},
onNotFound));
}
public async Task <TResult> RedeemTokenAsync <TResult>(
IDictionary <string, string> parameters,
IAuthApplication application,
Func <string, IRefOptional <Authorization>, IProvideLogin, IDictionary <string, string>, TResult> onSuccess,
Func <Guid?, IDictionary <string, string>, TResult> onLogout,
Func <string, TResult> onCouldNotConnect,
Func <string, TResult> onFailure)
{
var methodName = this.name;
var matchingLoginProviders = application.LoginProviders
.SelectValues()
.Where(loginProvider => loginProvider.Method == methodName)
.ToArray();
if (!matchingLoginProviders.Any())
{
return(onFailure("Method does not match any existing authentication."));
}
var matchingLoginProvider = matchingLoginProviders.First();
return(await matchingLoginProvider.RedeemTokenAsync(parameters,
(userKey, authorizationIdMaybe, deprecatedId, updatedParameters) =>
{
var allParameters = updatedParameters
.Concat(
parameters
.Where(param => !updatedParameters.ContainsKey(param.Key)))
.ToDictionary();
var authorizationRef = authorizationIdMaybe.HasValue ?
new RefOptional <Authorization>(authorizationIdMaybe.Value)
:
new RefOptional <Authorization>();
return onSuccess(userKey, authorizationRef,
matchingLoginProvider, allParameters);
},
(authorizationId, extraParams) => onLogout(authorizationId, extraParams),
(why) => onFailure(why),
(why) => onCouldNotConnect(why),
(why) => onFailure(why),
(why) => onFailure(why)));
}
public async static Task <IHttpResponse> CreateAsync(
[Property(Name = AccountPropertyName)] Guid accountId,
[PropertyOptional(Name = AuthorizationPropertyName)] IRefOptional <Authorization> authorizationRefMaybe,
[Resource] XIntegration integration,
IAuthApplication application, EastFive.Api.SessionToken security,
CreatedResponse onCreated,
AlreadyExistsResponse onAlreadyExists,
ForbiddenResponse onForbidden,
ReferencedDocumentDoesNotExistsResponse <Authorization> onAuthorizationDoesNotExist,
GeneralConflictResponse onFailure)
{
if (!await application.CanAdministerCredentialAsync(accountId, security))
{
return(onForbidden());
}
return(await await authorizationRefMaybe.StorageGetAsync(
async authorization =>
{
if (!await application.ShouldAuthorizeIntegrationAsync(integration, authorization))
{
return onFailure("Authorization is not accessable to this account.");
}
return await CreateWithAuthorization(integration, authorization,
() => onCreated(),
() => onAlreadyExists(),
(why) => onFailure(why));
},
async() =>
{
if (authorizationRefMaybe.HasValue)
{
return onAuthorizationDoesNotExist();
}
return await integration.StorageCreateAsync(
(discard) => onCreated(),
() => onAlreadyExists());
}));
}
public static async Task <IHttpResponse> DeleteAsync(
[UpdateId(Name = IntegrationIdPropertyName)] IRef <XIntegration> integrationRef,
IAuthApplication application, EastFive.Api.SessionToken security,
NoContentResponse onDeleted,
NotFoundResponse onNotFound,
ForbiddenResponse onForbidden)
{
var integrationMaybe = await integrationRef.StorageGetAsync(i => i, () => default(XIntegration?));
if (!integrationMaybe.HasValue)
{
return(onNotFound());
}
var integration = integrationMaybe.Value;
if (!await application.CanAdministerCredentialAsync(integration.accountId, security))
{
return(onForbidden());
}
return(await DeleteInternalAsync(integrationRef, () => onDeleted(), () => onNotFound()));
}
private static async Task <TResult> GetClaimsAsync <TResult>(
IAuthApplication application, IRefOptional <Authorization> authorizationRefMaybe,
Func <IDictionary <string, string>, Guid?, bool, TResult> onClaims,
Func <string, TResult> onFailure)
{
if (!authorizationRefMaybe.HasValueNotNull())
{
return(onClaims(new Dictionary <string, string>(), default(Guid?), false));
}
var authorizationRef = authorizationRefMaybe.Ref;
return(await Api.AppSettings.ActorIdClaimType.ConfigurationString(
(accountIdClaimType) =>
{
return GetSessionAcountAsync(authorizationRef, application,
(accountId, claims, authorized) =>
{
var claimsWithAccountId = claims
.Append(accountIdClaimType.PairWithValue(accountId.ToString()))
.ToDictionary();
return onClaims(claimsWithAccountId, accountId, authorized);
},
(why, authorized) => onClaims(new Dictionary <string, string>(), default(Guid?), authorized));
},
(why) =>
{
return GetSessionAcountAsync(authorizationRef, application,
(accountId, claims, authorized) =>
{
var claimsDictionary = claims
.NullToEmpty()
.ToDictionary();
return onClaims(claimsDictionary, accountId, authorized);
},
(why, authorized) => onClaims(new Dictionary <string, string>(), default(Guid?), authorized));
}));
}
public Task <TResult> ParseTokenAsync <TResult>(IDictionary <string, string> parameters,
IAuthApplication application,
Func <string, IProvideLogin, TResult> onParsed,
Func <string, TResult> onFailure)
{
var methodName = this.name;
var matchingLoginProviders = application.LoginProviders
.SelectValues()
.Where(loginProvider => loginProvider.Method == methodName)
.ToArray();
if (!matchingLoginProviders.Any())
{
return(onFailure("Method does not match any existing authentication.").AsTask());
}
var matchingLoginProvider = matchingLoginProviders.First();
return(matchingLoginProvider.ParseCredentailParameters(parameters,
(externalId, authorizationIdMaybeDiscard, lookupDiscard) =>
{
return onParsed(externalId, matchingLoginProvider);
},
onFailure).AsTask());
}
public async static Task <IHttpResponse> CreateAsync(
[Api.Meta.Flows.WorkflowNewId]
[Property(Name = AuthorizationIdPropertyName)]
IRef <Authorization> authorizationRef,
[Api.Meta.Flows.WorkflowParameter(Value = "{{AuthenticationMethod}}")]
[Property(Name = MethodPropertyName)]
IRef <Method> method,
[Api.Meta.Flows.WorkflowParameter(Value = "http://example.com")]
[Property(Name = LocationAuthorizationReturnPropertyName)]
Uri locationAuthenticationReturn,
[Resource] Authorization authorization,
IAuthApplication application, IProvideUrl urlHelper,
CreatedBodyResponse <Authorization> onCreated,
AlreadyExistsResponse onAlreadyExists,
ReferencedDocumentDoesNotExistsResponse <Method> onAuthenticationDoesNotExist)
{
authorization.accountIdMaybe = default;
authorization.authorized = false;
return(await await Auth.Method.ById(method, application,
async (method) =>
{
//var authorizationIdSecure = authentication.authenticationId;
authorization.LocationAuthentication = await method.GetLoginUrlAsync(
application, urlHelper, authorizationRef.id);
//throw new ArgumentNullException();
return await authorization.StorageCreateAsync(
createdId => onCreated(authorization),
() => onAlreadyExists());
},
() => onAuthenticationDoesNotExist().AsTask()));
}
public static IEnumerableAsync <Method> DeleteInCredentialProviders(this AccountLinks accountLinks, IAuthApplication application)
{
var loginProvidersWithMethods = application.LoginProviders
.SelectValues()
.Select(
loginProvider =>
{
var method = Method.ByMethodName(loginProvider.Method, application);
return(method, loginProvider);
});
var(accountLinkMethodLoginProviderKvps, unmatched1, unmatched2) = accountLinks.accountLinks
.Match(loginProvidersWithMethods,
(accountLink, methodLoginProvider) => accountLink.method.id == methodLoginProvider.method.id);
return(accountLinkMethodLoginProviderKvps
.Where(tpl => tpl.Item2.loginProvider is IProvideLoginManagement)
.Select(
async accountLinkLoginProvider =>
{
var(accountLink, (method, loginProvider)) = accountLinkLoginProvider;
var loginManager = loginProvider as IProvideLoginManagement;
return await loginManager.DeleteAuthorizationAsync(accountLink.externalAccountKey,
() => method,
why => default(Method?),
() => default,
public AuthController(IAuthApplication authApplication)
{
_authApplication = authApplication;
}