public async Task <IActionResult> Index(string returnUrl, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(returnUrl))
{
return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}", area = string.Empty }));
}
try
{
var query = Unprotect(returnUrl).GetQueries().ToJObj();
var clientId = query.GetClientIdFromAuthorizationRequest();
var client = await OAuthClientQueryRepository.FindOAuthClientById(clientId, cancellationToken);
var loginHint = query.GetLoginHintFromAuthorizationRequest();
return(View(new AuthenticateViewModel(returnUrl,
loginHint,
_translationHelper.Translate(client.ClientNames),
_translationHelper.Translate(client.LogoUris),
_translationHelper.Translate(client.TosUris),
_translationHelper.Translate(client.PolicyUris))));
}
catch (CryptographicException)
{
return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}", area = string.Empty }));
}
}
public async Task <IActionResult> Index(string returnUrl, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(returnUrl))
{
return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}", area = string.Empty }));
}
try
{
var schemes = await _authenticationSchemeProvider.GetAllSchemesAsync();
var query = Unprotect(returnUrl).GetQueries().ToJObj();
var clientId = query.GetClientIdFromAuthorizationRequest();
var client = await OAuthClientQueryRepository.FindOAuthClientById(clientId, cancellationToken);
var loginHint = query.GetLoginHintFromAuthorizationRequest();
var externalIdProviders = schemes.Where(s => !string.IsNullOrWhiteSpace(s.DisplayName));
return(View(new AuthenticateViewModel(
loginHint,
returnUrl,
_translationHelper.Translate(client.ClientNames),
_translationHelper.Translate(client.LogoUris),
_translationHelper.Translate(client.TosUris),
_translationHelper.Translate(client.PolicyUris),
externalIdProviders.Select(e => new OpenID.UI.ViewModels.ExternalIdProvider
{
AuthenticationScheme = e.Name,
DisplayName = e.DisplayName
}).ToList())));
}
catch (CryptographicException)
{
return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}", area = string.Empty }));
}
}
public async Task <IActionResult> Index(string returnUrl, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(returnUrl))
{
return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}" }));
}
try
{
var unprotectedUrl = _dataProtector.Unprotect(returnUrl);
var query = unprotectedUrl.GetQueries().ToJObj();
var clientId = query.GetClientIdFromAuthorizationRequest();
var oauthClient = await _oauthClientRepository.FindOAuthClientById(clientId, cancellationToken);
query = await _extractRequestHelper.Extract(Request.GetAbsoluteUriWithVirtualPath(), query, oauthClient);
var scopes = query.GetScopesFromAuthorizationRequest();
var claims = query.GetClaimsFromAuthorizationRequest();
var claimDescriptions = new List <string>();
if (claims != null && claims.Any())
{
claimDescriptions = claims.Select(c => c.Name).ToList();
}
return(View(new ConsentsIndexViewModel(
_translationHelper.Translate(oauthClient.ClientNames, oauthClient.ClientId),
returnUrl,
oauthClient.AllowedScopes.Where(c => scopes.Contains(c.Name)).Select(s => s.Name),
claimDescriptions)));
}
catch (CryptographicException)
{
return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}" }));
}
}
public async Task <NotificationDetailsResult> Handle(GetNotificationsDetailsQuery request, CancellationToken cancellationToken)
{
var result = await _notificationInstanceQueryRepository.Get(request.NotificationId, cancellationToken);
if (result == null)
{
_logger.LogError($"Notification '{request.NotificationId}' doesn't exist");
throw new UnknownNotificationException(string.Format(Global.UnknownNotification, request.NotificationId));
}
var callbackTxt = new Func <ICollection <PresentationElementInstance>, Localization.Translation>((t) =>
{
if (t == null || !t.Any())
{
return(null);
}
try
{
return(_translationHelper.Translate(t));
}
catch (BadOperationExceptions) { return(null); }
});
var name = callbackTxt(result.Names);
var subject = callbackTxt(result.Subjects);
return(NotificationDetailsResult.ToDto(result, name, subject));
}
public async Task <SearchResult <NotificationDetailsResult> > Handle(SearchNotificationsQuery request, CancellationToken cancellationToken)
{
if (request.Claims == null || !request.Claims.Any())
{
_logger.LogError("User is not authenticated");
throw new NotAuthenticatedException(Global.UserNotAuthenticated);
}
var userClaims = new UserClaims
{
UserIdentifier = _authorizationHelper.GetNameIdentifier(request.Claims),
Roles = _authorizationHelper.GetRoles(request.Claims),
LogicalGroups = (await _logicalPeopleGroupStore.GetLogicalGroups(request.Claims, cancellationToken)).Select(_ => _.Name).ToList()
};
var result = await _notificationInstanceQueryRepository.Find(new FindNotificationInstanceParameter
{
Count = request.Count,
Order = request.Order,
OrderBy = request.OrderBy,
StartIndex = request.StartIndex,
User = userClaims
}, cancellationToken);
var content = new List <NotificationDetailsResult>();
foreach (var record in result.Content)
{
var callbackTxt = new Func <ICollection <PresentationElementInstance>, Localization.Translation>((t) =>
{
if (t == null || !t.Any())
{
return(null);
}
try
{
return(_translationHelper.Translate(t));
}
catch (BadOperationExceptions) { return(null); }
});
var name = callbackTxt(record.Names);
var subject = callbackTxt(record.Subjects);
content.Add(NotificationDetailsResult.ToDto(record, name, subject));
}
return(new SearchResult <NotificationDetailsResult>
{
StartIndex = result.StartIndex,
TotalLength = result.TotalLength,
Count = result.Count,
Content = content
});
}
public async Task <SearchResult <TaskInstanceDetailsResult> > Handle(SearchHumanTaskInstanceDetailsQuery request, CancellationToken cancellationToken)
{
_logger.LogInformation("Search human task instance");
var nameIdentifier = _authorizationHelper.GetNameIdentifier(request.Claims);
var roles = _authorizationHelper.GetRoles(request.Claims);
var result = await _humanTaskInstanceQueryRepository.Search(new SearchHumanTaskInstanceParameter
{
UserIdentifier = nameIdentifier,
GroupNames = roles,
Count = request.Count,
Order = request.Order,
OrderBy = request.OrderBy,
StartIndex = request.StartIndex,
StatusLst = request.StatusLst,
ActualOwner = request.ActualOwner
}, cancellationToken);
var content = new List <TaskInstanceDetailsResult>();
foreach (var record in result.Content)
{
var callbackTxt = new Func <ICollection <PresentationElementInstance>, Localization.Translation>((t) =>
{
if (t == null || !t.Any())
{
return(null);
}
try
{
return(_translationHelper.Translate(t));
}
catch (BadOperationExceptions) { return(null); }
});
var appRoles = await _authorizationHelper.GetRoles(record, request.Claims, cancellationToken);
var name = callbackTxt(record.Names);
var subject = callbackTxt(record.Subjects);
content.Add(TaskInstanceDetailsResult.ToDto(record, name, subject, appRoles, _authorizationHelper.GetNameIdentifier(request.Claims)));
}
return(new SearchResult <TaskInstanceDetailsResult>
{
Count = result.Count,
TotalLength = result.TotalLength,
StartIndex = result.StartIndex,
Content = content
});
}
public async Task <TaskDescriptionResult> Handle(GetHumanTaskInstanceDescriptionQuery request, CancellationToken cancellationToken)
{
var humanTaskInstance = await _humanTaskInstanceQueryRepository.Get(request.HumanTaskInstanceId, cancellationToken);
if (humanTaskInstance == null)
{
_logger.LogError($"HumanTask '{request.HumanTaskInstanceId}' doesn't exist");
throw new UnknownHumanTaskInstanceException(string.Format(Global.UnknownHumanTaskInstance, request.HumanTaskInstanceId));
}
var translation = _translationHelper.Translate(humanTaskInstance.Descriptions);
return(new TaskDescriptionResult {
Description = translation.Value, ContentType = translation.ContentType
});
}
public async Task <SubTasksResults> Handle(GetHumanTaskInstanceSubTasksQuery request, CancellationToken cancellationToken)
{
var humanTaskInstance = await _humanTaskInstanceQueryRepository.Get(request.HumanTaskInstanceId, cancellationToken);
if (humanTaskInstance == null)
{
_logger.LogError($"HumanTask '{request.HumanTaskInstanceId}' doesn't exist");
throw new UnknownHumanTaskInstanceException(string.Format(Global.UnknownHumanTaskInstance, request.HumanTaskInstanceId));
}
var callbackTxt = new Func <ICollection <PresentationElementInstance>, Localization.Translation>((t) =>
{
if (t == null || !t.Any())
{
return(null);
}
try
{
return(_translationHelper.Translate(t));
}
catch (BadOperationExceptions) { return(null); }
});
var result = await _humanTaskInstanceQueryRepository.GetSubTasks(humanTaskInstance.AggregateId, cancellationToken);
ICollection <TaskInstanceDetailsResult> content = result.Select(_ =>
{
var name = callbackTxt(_.Names);
var subject = callbackTxt(_.Subjects);
return(TaskInstanceDetailsResult.ToDto(_, name, subject, null, null));
}).ToList();
return(new SubTasksResults
{
Content = content
});
}
