[Api.HttpPost] //(MatchAllBodyParameters = false)]
public async static Task <HttpResponseMessage> CreateAsync(
[Property(Name = AccountPropertyName)] Guid accountId,
[Property(Name = AuthorizationPropertyName)] IRef <Authorization> authorizationRef,
[Resource] AccountMapping accountMapping,
Api.Azure.AzureApplication 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 async Task <InvocationMessage> InvocationMessageAsync(this IHttpRequest request,
int executionLimit = 1)
{
var invocationMessageRef = Ref <InvocationMessage> .SecureRef();
var referrer = request.TryGetReferer(out Uri refererTmp) ?
refererTmp
:
new Uri(System.Web.HttpUtility.UrlDecode(refererTmp.OriginalString));
var content = await request.ReadContentAsync();
var invocationMessage = new InvocationMessage
{
invocationRef = invocationMessageRef,
headers = request.Headers
.Select(hdr => hdr.Key.PairWithValue(hdr.Value.First()))
.ToDictionary(),
requestUri = new Uri(System.Web.HttpUtility.UrlDecode(request.RequestUri.OriginalString)),
referrer = referrer,
content = content,
invocationMessageSource = GetInvocationMessageSource(),
method = request.Method.Method,
executionHistory = new KeyValuePair <DateTime, int>[] { },
executionLimit = executionLimit,
};
return(invocationMessage);
IRefOptional <InvocationMessage> GetInvocationMessageSource()
{
if (!request.TryGetHeader(InvocationMessage.InvocationMessageSourceHeaderKey,
out string invocationMessageSourceStr))
{
return(RefOptional <InvocationMessage> .Empty());
}
if (!Guid.TryParse(invocationMessageSourceStr, out Guid invocationMessageSource))
{
return(RefOptional <InvocationMessage> .Empty());
}
return(invocationMessageSource.AsRefOptional <InvocationMessage>());
}
}
internal static async Task <TResult> CreateByMethodAndKeyAsync <TResult>(Authorization authorization,
string externalAccountKey, Guid internalAccountId,
Func <TResult> onCreated,
Func <TResult> onAlreadyMapped,
bool shouldRemap = false)
{
var accountMapping = new AccountMapping()
{
accountId = internalAccountId,
};
accountMapping.Method = authorization.Method; // method is used in the .mappingId
accountMapping.authorization = authorization.authorizationRef;
var authorizationLookup = new AuthorizationLookup
{
accountMappingRef = accountMapping.mappingId,
authorizationLookupRef = authorization.authorizationRef,
};
bool created = await authorizationLookup.StorageCreateAsync(
(idDiscard) =>
{
return(true);
},
() =>
{
// I guess this is cool...
return(false);
});
var lookup = new AccountMappingLookup()
{
accountkey = externalAccountKey,
accountMappingId = accountMapping.mappingId,
Method = authorization.Method,
};
accountMapping.accountMappingLookup = await await lookup.StorageCreateAsync(
(discard) => lookup.accountMappingLookupId.Optional().AsTask(),
async() =>
{
if (!shouldRemap)
{
return(RefOptional <AccountMappingLookup> .Empty());
}
return(await lookup.accountMappingLookupId.StorageCreateOrUpdateAsync(
async(created, lookupToUpdate, saveAsync) =>
{
lookupToUpdate.accountMappingId = accountMapping.mappingId;
await saveAsync(lookupToUpdate);
return lookupToUpdate.accountMappingLookupId.Optional();
}));
});
return(await await accountMapping.StorageCreateAsync(
createdId =>
{
return onCreated().AsTask();
},
async() =>
{
if (!shouldRemap)
{
return onAlreadyMapped();
}
return await accountMapping.mappingId.StorageCreateOrUpdateAsync(
async(created, mapping, saveAsync) =>
{
mapping.accountMappingLookup = accountMapping.accountMappingLookup;
mapping.authorization = accountMapping.authorization;
await saveAsync(mapping);
return onCreated();
});
}));
}
public static async Task <IHttpResponse> ProcessRequestAsync(
EastFive.Azure.Auth.Method method,
IDictionary <string, string> values,
IAzureApplication application,
IHttpRequest request,
IInvokeApplication endpoints,
IProvideUrl urlHelper,
Func <Uri, Guid?, IHttpResponse> onRedirect,
Func <string, IHttpResponse> onAuthorizationnotFound,
Func <string, IHttpResponse> onCouldNotConnect,
Func <string, IHttpResponse> onFailure)
{
//var authorizationRequestManager = application.AuthorizationRequestManager;
var telemetry = application.Telemetry;
telemetry.TrackEvent($"ResponseController.ProcessRequestAsync - Requesting credential manager.");
var requestId = Guid.NewGuid();
request.TryGetReferer(out Uri referer);
var redirection = new Redirection
{
webDataRef = requestId.AsRef <Redirection>(),
method = method.authenticationId,
values = values,
redirectedFrom = referer,
};
return(await await redirection.StorageCreateAsync(
discard =>
{
return EastFive.Azure.AppSettings.Auth.PauseRedirections.ConfigurationBoolean(
async pauseRedirections =>
{
if (pauseRedirections)
{
return request.CreateResponse(System.Net.HttpStatusCode.OK, $"All logins have been paused for this system. Request ID `{requestId}`");
}
return await ContinueAsync();
},
why => ContinueAsync(),
ContinueAsync);
Task <IHttpResponse> ContinueAsync()
{
var baseUri = request.RequestUri;
return AuthenticationAsync(
method, values, application, request, endpoints,
request.RequestUri,
RefOptional <Authorization> .Empty(),
(uri, accountIdMaybe, modifier) =>
{
var response = onRedirect(uri, accountIdMaybe);
return modifier(response);
},
() => onAuthorizationnotFound("Authorization not found"),
onCouldNotConnect,
onFailure);
}
},
() => onFailure("GUID NOT UNIQUE").AsTask()));
}
