public static async Task <IHttpResponse> ReplayAsync(
[QueryId(Name = AuthorizationIdPropertyName)] IRef <Authorization> authorizationRef,
Api.Azure.AzureApplication application,
IInvokeApplication endpoints,
IHttpRequest request,
ContentTypeResponse <Session> onReplayed,
NotFoundResponse onNotFound,
ForbiddenResponse onAuthorizationFailed,
ServiceUnavailableResponse onServericeUnavailable,
ForbiddenResponse onInvalidMethod,
GeneralConflictResponse onFailure)
{
return(await await authorizationRef.StorageGetAsync(
async (authorization) =>
{
var methodRef = authorization.Method;
return await await Auth.Method.ById(methodRef, application,
async(method) =>
{
var paramsUpdated = authorization.parameters
.Append(authorizationRef.id.ToString().PairWithKey("state"))
.ToDictionary();
//var authorizationRequestManager = application.AuthorizationRequestManager;
return await await Redirection.AuthenticationAsync(
method,
paramsUpdated,
application, request,
endpoints,
request.RequestUri,
authorizationRef.Optional(),
async(redirect, accountIdMaybe, modifier) =>
{
var sessionRef = Ref <Session> .SecureRef();
var session = new Session()
{
sessionId = sessionRef,
account = accountIdMaybe,
authorization = authorizationRef.Optional(),
};
var responseCreated = await Session.CreateAsync(sessionRef, authorizationRef.Optional(),
session,
application,
(sessionCreated, contentType) =>
{
var response = onReplayed(sessionCreated, contentType: contentType);
response.SetLocation(redirect);
return response;
},
onAlreadyExists: default,
public static async Task <TResult> CreateByMethodAndKeyAsync <TResult>(IRef <XIntegration> integrationRef,
IRef <Authorization> authorizationRef, IRef <Method> methodRef,
Guid accountId, IDictionary <string, string> parameters,
Func <XIntegration, Authorization, TResult> onCreated,
Func <TResult> onIntegrationAlreadyExists,
Func <TResult> onAuthorizationAlreadyExists,
Func <string, TResult> onFailure)
{
var authorization = new Authorization
{
authorizationRef = authorizationRef,
parameters = parameters,
Method = methodRef,
authorized = true,
accountIdMaybe = accountId,
};
return(await await authorization.StorageCreateAsync <Authorization, Task <TResult> >(
(discardId) =>
{
var integration = new XIntegration
{
integrationRef = integrationRef,
accountId = accountId,
authorization = authorizationRef.Optional(),
Method = methodRef,
};
return CreateWithAuthorization(integration, authorization,
() => onCreated(integration, authorization),
() => onIntegrationAlreadyExists(),
(why) => onFailure(why));
},
() => onAuthorizationAlreadyExists().AsTask()));
}
[Api.HttpPatch] //(MatchAllBodyParameters = false)]
public async static Task <IHttpResponse> UpdateAsync(
[Property(Name = IntegrationIdPropertyName)] IRef <XIntegration> integrationRef,
[Property(Name = AuthorizationPropertyName)] IRef <Authorization> authorizationRef,
Api.Azure.AzureApplication application, EastFive.Api.SessionToken security,
ContentTypeResponse <XIntegration> onUpdated,
NotFoundResponse onNotFound,
ForbiddenResponse onForbidden,
ReferencedDocumentDoesNotExistsResponse <Authorization> onAuthorizationDoesNotExist,
UnauthorizedResponse onUnauthorized)
{
return(await integrationRef.StorageUpdateAsync(
async (integration, saveAsync) =>
{
var accountId = integration.accountId;
if (!await application.CanAdministerCredentialAsync(accountId, security))
{
return onUnauthorized();
}
return await await authorizationRef.StorageGetAsync(
async authorization =>
{
if (!await application.ShouldAuthorizeIntegrationAsync(integration, authorization))
{
return onForbidden().AddReason("Authorization is not accessable to this account.");
}
integration.Method = authorization.Method; // method is used in the .mappingId
integration.authorization = authorizationRef.Optional();
integration.methodName = await Auth.Method.ById(authorization.Method,
application,
method => method.name,
() => string.Empty);
await saveAsync(integration);
return onUpdated(integration);
},
() => onAuthorizationDoesNotExist().AsTask());
},
() => onNotFound(),
onModificationFailures:
StorageConstraintUniqueAttribute.ModificationFailure(
(XIntegration x) => x.authorization,
() =>
{
// TODO: Check if mapping is to this integration and reply already created.
return onForbidden().AddReason("Authorization is already in use.");
}).AsArray()));
}
public static async Task <TResult> CreateByMethodAndKeyAsync <TResult>(IRef <Integration> integrationRef,
IRef <Authorization> authorizationRef, IRef <Method> methodRef,
Guid accountId, IDictionary <string, string> parameters,
Func <Integration, Authorization, TResult> onCreated,
Func <TResult> onIntegrationAlreadyExists,
Func <TResult> onAuthorizationAlreadyExists = default,
Func <string, TResult> onFailure = default)
{
var authorization = new Authorization
{
authorizationRef = authorizationRef,
parameters = parameters,
Method = methodRef,
authorized = true,
accountIdMaybe = accountId,
};
return(await await authorization.StorageCreateAsync <Authorization, Task <TResult> >(
(discardId) =>
{
var integration = new Integration
{
integrationRef = integrationRef,
accountId = accountId,
authorization = authorizationRef.Optional(),
Method = methodRef,
};
return CreateWithAuthorization(integration, authorization,
accountId,
() => onCreated(integration, authorization),
() => onIntegrationAlreadyExists(),
(why) =>
{
if (why.IsDefaultOrNull())
{
throw new Exception(why);
}
return onFailure(why);
});
},
() =>
{
if (onAuthorizationAlreadyExists.IsDefaultOrNull())
{
throw new Exception("Could not create authorization that already exists.");
}
return onAuthorizationAlreadyExists().AsTask();
}));
}
[Api.HttpPatch] //(MatchAllBodyParameters = false)]
public async static Task <HttpResponseMessage> UpdateAsync(
[Property(Name = IntegrationIdPropertyName)] IRef <Integration> integrationRef,
[Property(Name = AuthorizationPropertyName)] IRef <Authorization> authorizationRef,
Api.Azure.AzureApplication application, EastFive.Api.SessionToken security,
ContentTypeResponse <Integration> onUpdated,
NotFoundResponse onNotFound,
NotModifiedResponse onNotModified,
ForbiddenResponse onForbidden,
ReferencedDocumentDoesNotExistsResponse <Authorization> onAuthenticationDoesNotExist,
UnauthorizedResponse onUnauthorized)
{
return(await integrationRef.StorageUpdateAsync(
async (integration, saveAsync) =>
{
var accountId = integration.accountId;
if (!await application.CanAdministerCredentialAsync(accountId, security))
{
return onUnauthorized();
}
return await await authorizationRef.StorageGetAsync(
async authorization =>
{
// TODO? This
// var accountIdDidMatch = await await authorization.ParseCredentailParameters(
integration.Method = authorization.Method; // method is used in the .mappingId
integration.authorization = authorizationRef.Optional();
return await await SaveAuthorizationLookupAsync(integration.integrationRef, authorization.authorizationRef,
async() =>
{
await saveAsync(integration);
return await SaveAccountLookupAsync(accountId, integration,
() => onUpdated(integration));
},
() =>
{
// TODO: Check if mapping is to this integration and reply already created.
return onForbidden().AddReason("Authorization is already in use.").AsTask();
});
},
() =>
{
return onNotModified().AsTask();
});
},
() => onNotFound()));
}
public static Task <HttpResponseMessage> GetByRequestIdAsync(
[QueryParameter(Name = SessionIdPropertyName, CheckFileName = true)] IRef <Session> sessionRef,
[QueryParameter(Name = "request_id")] IRef <Authorization> authorization,
EastFive.Api.SessionToken security,
Api.Azure.AzureApplication application, UrlHelper urlHelper,
ContentTypeResponse <Session> onUpdated,
NotFoundResponse onNotFound,
ForbiddenResponse forbidden,
ConfigurationFailureResponse onConfigurationFailure,
GeneralConflictResponse onFailure)
{
return(UpdateBodyAsync(sessionRef, authorization.Optional(),
application,
onUpdated,
onNotFound,
forbidden,
onConfigurationFailure,
onFailure));
}
public async static Task <IHttpResponse> CreateAuthorizedAsync(
[UpdateId(Name = AuthorizationIdPropertyName)] IRef <Authorization> authorizationRef,
[Property(Name = MethodPropertyName)] IRef <Method> methodRef,
[Property(Name = ParametersPropertyName)] IDictionary <string, string> parameters,
[Resource] Authorization authorization,
Api.Azure.AzureApplication application, IProvideUrl urlHelper,
IInvokeApplication endpoints,
IHttpRequest request,
CreatedResponse onCreated,
AlreadyExistsResponse onAlreadyExists,
ForbiddenResponse onAuthorizationFailed,
ServiceUnavailableResponse onServericeUnavailable,
ForbiddenResponse onInvalidMethod)
{
authorization.accountIdMaybe = default;
authorization.authorized = false;
return(await await Auth.Method.ById(methodRef, application,
(method) =>
{
var paramsUpdated = parameters;
//.Append(
// authorizationRef.id.ToString().PairWithKey("state"))
//.ToDictionary();
return Redirection.AuthenticationAsync(
method,
paramsUpdated,
application, request, endpoints, request.RequestUri,
authorizationRef.Optional(),
(redirect, accountIdMaybe, discardModifier) => onCreated(),
() => onAuthorizationFailed().AddReason("Authorization was not found"), // Bad credentials
why => onServericeUnavailable().AddReason(why),
why => onAuthorizationFailed().AddReason(why));
},
() => onInvalidMethod().AddReason("The method was not found.").AsTask()));
}