public async Task Handle(GetUserInformationReceived parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
var payload = _serializer.GetPayload(parameter);
await AddEvent(parameter.Id, parameter.ProcessId, payload, "Start user information", parameter.Order);
}
public async Task Handle(RegistrationReceived message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var payload = _serializer.GetPayload(message);
await _repository.Add(new EventAggregate
{
Id = message.Id,
AggregateId = message.ProcessId,
Description = "Start client registration",
CreatedOn = DateTime.UtcNow,
Payload = payload,
Order = message.Order
});
}
public async Task Handle(GrantTokenViaAuthorizationCodeReceived message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var payload = _serializer.GetPayload(message);
await Add(message.Id, message.ProcessId, payload, "Start grant token via authorization code", message.Order);
}
public async Task <ActionResult> GetAuthorization(AuthorizationParameter parameter, IPrincipal claimsPrincipal)
{
var processId = Guid.NewGuid().ToString();
_eventPublisher.Publish(new AuthorizationRequestReceived(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(parameter), 0));
try
{
var client = await _authorizationCodeGrantTypeParameterValidator.ValidateAsync(parameter);
ActionResult actionResult = null;
_simpleIdentityServerEventSource.StartAuthorization(parameter.ClientId,
parameter.ResponseType,
parameter.Scope,
parameter.Claims == null ? string.Empty : parameter.Claims.ToString());
if (client.RequirePkce && (string.IsNullOrWhiteSpace(parameter.CodeChallenge) || parameter.CodeChallengeMethod == null))
{
throw new IdentityServerException(ErrorCodes.InvalidRequestCode, string.Format(ErrorDescriptions.TheClientRequiresPkce, parameter.ClientId));
}
var responseTypes = _parameterParserHelper.ParseResponseTypes(parameter.ResponseType);
var authorizationFlow = _authorizationFlowHelper.GetAuthorizationFlow(responseTypes, parameter.State);
switch (authorizationFlow)
{
case AuthorizationFlow.AuthorizationCodeFlow:
actionResult = await _getAuthorizationCodeOperation.Execute(parameter, claimsPrincipal, client);
break;
case AuthorizationFlow.ImplicitFlow:
actionResult = await _getTokenViaImplicitWorkflowOperation.Execute(parameter, claimsPrincipal, client);
break;
case AuthorizationFlow.HybridFlow:
actionResult = await _getAuthorizationCodeAndTokenViaHybridWorkflowOperation.Execute(parameter, claimsPrincipal, client);
break;
}
if (actionResult != null)
{
var actionTypeName = Enum.GetName(typeof(TypeActionResult), actionResult.Type);
var actionName = string.Empty;
if (actionResult.Type == TypeActionResult.RedirectToAction)
{
var actionEnum = actionResult.RedirectInstruction.Action;
actionName = Enum.GetName(typeof(IdentityServerEndPoints), actionEnum);
}
var serializedParameters = actionResult.RedirectInstruction == null || actionResult.RedirectInstruction.Parameters == null ? String.Empty :
actionResult.RedirectInstruction.Parameters.SerializeWithJavascript();
_simpleIdentityServerEventSource.EndAuthorization(actionTypeName,
actionName,
serializedParameters);
}
_eventPublisher.Publish(new AuthorizationGranted(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(actionResult), 1));
actionResult.ProcessId = processId;
return(actionResult);
}
catch (IdentityServerException ex)
{
_eventPublisher.Publish(new OpenIdErrorReceived(Guid.NewGuid().ToString(), processId, ex.Code, ex.Message, 1));
throw;
}
}
public async Task <IntrospectionResult> PostIntrospection(IntrospectionParameter introspectionParameter, AuthenticationHeaderValue authenticationHeaderValue)
{
if (introspectionParameter == null)
{
throw new ArgumentNullException(nameof(introspectionParameter));
}
var processId = Guid.NewGuid().ToString();
try
{
_eventPublisher.Publish(new IntrospectionRequestReceived(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(introspectionParameter, authenticationHeaderValue), authenticationHeaderValue, 0));
var result = await _postIntrospectionAction.Execute(introspectionParameter, authenticationHeaderValue);
_eventPublisher.Publish(new IntrospectionResultReturned(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(result), 1));
return(result);
}
catch (IdentityServerException ex)
{
_eventPublisher.Publish(new OpenIdErrorReceived(Guid.NewGuid().ToString(), processId, ex.Code, ex.Message, 1));
throw;
}
}
public async Task <ClientRegistrationResponse> PostRegistration(RegistrationParameter registrationParameter)
{
if (registrationParameter == null)
{
throw new ArgumentNullException(nameof(registrationParameter));
}
var processId = Guid.NewGuid().ToString();
try
{
_eventPublisher.Publish(new RegistrationReceived(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(registrationParameter), 0));
var result = await _registerClientAction.Execute(registrationParameter);
_eventPublisher.Publish(new RegistrationResultReceived(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(result), 1));
return(result);
}
catch (IdentityServerException ex)
{
_eventPublisher.Publish(new OAuthErrorReceived(Guid.NewGuid().ToString(), processId, ex.Code, ex.Message, 1));
throw;
}
}
protected void LogAuthenticateUser(Core.Results.ActionResult act, string processId)
{
if (string.IsNullOrWhiteSpace(processId))
{
return;
}
_eventPublisher.Publish(new ResourceOwnerAuthenticated(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(act), 2));
}
public async Task <GrantedToken> GetTokenByResourceOwnerCredentialsGrantType(
ResourceOwnerGrantTypeParameter resourceOwnerGrantTypeParameter,
AuthenticationHeaderValue authenticationHeaderValue,
X509Certificate2 certificate = null)
{
if (resourceOwnerGrantTypeParameter == null)
{
throw new ArgumentNullException(nameof(resourceOwnerGrantTypeParameter));
}
var processId = Guid.NewGuid().ToString();
try
{
_eventPublisher.Publish(new GrantTokenViaResourceOwnerCredentialsReceived(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(resourceOwnerGrantTypeParameter, authenticationHeaderValue), authenticationHeaderValue, 0));
_simpleIdentityServerEventSource.StartGetTokenByResourceOwnerCredentials(resourceOwnerGrantTypeParameter.ClientId,
resourceOwnerGrantTypeParameter.UserName,
resourceOwnerGrantTypeParameter.Password);
_resourceOwnerGrantTypeParameterValidator.Validate(resourceOwnerGrantTypeParameter);
var result = await _getTokenByResourceOwnerCredentialsGrantType.Execute(resourceOwnerGrantTypeParameter,
authenticationHeaderValue, certificate);
var accessToken = result != null ? result.AccessToken : string.Empty;
var identityToken = result != null ? result.IdToken : string.Empty;
_simpleIdentityServerEventSource.EndGetTokenByResourceOwnerCredentials(accessToken, identityToken);
_eventPublisher.Publish(new TokenGranted(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(result), 1));
return(result);
}
catch (IdentityServerException ex)
{
_eventPublisher.Publish(new OpenIdErrorReceived(Guid.NewGuid().ToString(), processId, ex.Code, ex.Message, 1));
throw;
}
}
public async Task <UserInfoResult> GetUserInformation(string accessToken)
{
var processId = Guid.NewGuid().ToString();
try
{
_eventPublisher.Publish(new GetUserInformationReceived(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(accessToken), 0));
var result = await _getJwsPayload.Execute(accessToken);
_eventPublisher.Publish(new UserInformationReturned(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(result), 1));
return(result);
}
catch (IdentityServerException ex)
{
_eventPublisher.Publish(new OpenIdErrorReceived(Guid.NewGuid().ToString(), processId, ex.Code, ex.Message, 1));
throw;
}
}
private async Task LogConsentAccepted(Core.Results.ActionResult act, string processId)
{
if (string.IsNullOrWhiteSpace(processId))
{
return;
}
var evtAggregate = await GetLastEventAggregate(processId);
if (evtAggregate == null)
{
return;
}
_eventPublisher.Publish(new ConsentAccepted(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(act), evtAggregate.Order + 1));
}
private async Task LogConsentAccepted(Core.Results.ActionResult act, string processId)
{
if (string.IsNullOrWhiteSpace(processId))
{
return;
}
_eventPublisher.Publish(new ConsentAccepted(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(act), 10));
}
private async Task LogAuthenticateUser(SimpleIdentityServer.Core.Results.ActionResult act, string processId)
{
if (string.IsNullOrWhiteSpace(processId))
{
return;
}
var evtAggregate = await GetLastEventAggregate(processId);
if (evtAggregate == null)
{
return;
}
_eventPublisher.Publish(new ResourceOwnerAuthenticated(Guid.NewGuid().ToString(), processId, _payloadSerializer.GetPayload(act), evtAggregate.Order + 1));
}