public bool TryAuthorize(string authorization,
string key,
[NotNullWhen(false)] out IActionResult?failure,
[NotNullWhen(true)] out IServerInstance?instance)
{
instance = null;
if (!AuthorizationUtility.TryParseBasicAuthentication(authorization, out failure, out var authKey,
out var token))
{
return(false);
}
if (authKey != key)
{
failure = Forbid();
return(false);
}
if (!_serverManager.TryGetInstance(key, out instance))
{
failure = NotFound();
return(false);
}
// TODO: we probably need constant-time comparisons for this?
// Maybe?
if (token != instance.Secret)
{
failure = Unauthorized();
return(false);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="output"></param>
public void Standard(GetCustomerOutput output)
{
var customerModel = new CustomerModel((Customer)output.Customer);
var getCustomerDetailsResponse = new GetCustomerDetailsResponse(customerModel);
this.ViewModel = new OkObjectResult(getCustomerDetailsResponse);
}
/// <summary>
/// Initializes a new instance of <see cref="AfterHandlerMethodEventData"/>.
/// </summary>
/// <param name="actionContext">The action context.</param>
/// <param name="arguments">The arguments to the method.</param>
/// <param name="handlerMethodDescriptor">The method descriptor.</param>
/// <param name="instance">The instance.</param>
/// <param name="result">The result of the handler method</param>
public AfterHandlerMethodEventData(ActionContext actionContext, IReadOnlyDictionary <string, object?> arguments, HandlerMethodDescriptor handlerMethodDescriptor, object instance, IActionResult?result)
{
ActionContext = actionContext;
Arguments = arguments;
HandlerMethodDescriptor = handlerMethodDescriptor;
Instance = instance;
Result = result;
}
/// <inheritdoc/>
public void SpaceNotFound(string message)
{
ViewModel = new NotFoundObjectResult(new ProblemDetails
{
Status = StatusCodes.Status404NotFound,
Title = "Space not found",
Detail = message,
});
}
/// <inheritdoc/>
public void PageAlreadyExists(string message)
{
ViewModel = new ConflictObjectResult(new ProblemDetails
{
Status = StatusCodes.Status409Conflict,
Title = "Page already exists",
Detail = message,
});
}
/// <inheritdoc/>
public void UnableToCreatePage(string message)
{
ViewModel = new UnprocessableEntityObjectResult(new ProblemDetails
{
Status = StatusCodes.Status422UnprocessableEntity,
Title = "Unable to create page",
Detail = message,
});
}
/// <summary>
/// Standard.
/// </summary>
/// <param name="output">Output.</param>
public void Standard(WithdrawOutput output)
{
var debitModel = new DebitModel((Debit)output.Transaction);
var withdrawResponse = new WithdrawResponse(
debitModel,
output.UpdatedBalance.ToDecimal());
this.ViewModel = new ObjectResult(withdrawResponse);
}
void IOutputPort.OutOfFunds()
{
Dictionary <string, string[]> messages = new Dictionary <string, string[]> {
{ "", new[] { "Out of funds." } }
};
ValidationProblemDetails problemDetails = new ValidationProblemDetails(messages);
this._viewModel = this.BadRequest(problemDetails);
}
/// <summary>
/// Standard.
/// </summary>
/// <param name="output">Output.</param>
public void Standard(DepositOutput output)
{
var depositEntity = (Credit)output.Transaction;
var depositResponse = new DepositResponse(
depositEntity.Amount.ToMoney().ToDecimal(),
Credit.Description,
depositEntity.TransactionDate,
output.UpdatedBalance.ToDecimal());
this.ViewModel = new ObjectResult(depositResponse);
}
/// <summary>
/// When the customer already exists and we are returning from DB.
/// </summary>
/// <param name="output">Output.</param>
public void HandleAlreadyRegisteredCustomer(RegisterOutput output)
{
var customerModel = new CustomerModel((Customer)output.Customer);
var accountsModel =
(from Account accountEntity in output.Accounts
select new AccountModel(accountEntity))
.ToList();
var registerResponse = new RegisterResponse(customerModel, accountsModel);
this.ViewModel = new OkObjectResult(registerResponse);
}
private bool IsSsoTimedOut(Session session, out IActionResult?result)
{
if (session.SsoStartTime == null || DateTime.UtcNow - session.SsoStartTime > SsoTimeout)
{
result = Redirect(QueryHelpers.AddQueryString("/login", "error",
"The login attempt has expired. Please try again."));
return(true);
}
result = null;
return(false);
}
public override bool BeforeSave(User model, out IActionResult?error)
{
if (model.PublicKey == null || model.PublicKey.Length == 0)
{
unsafe
{
Crypto.GenerateKeyPair(out var pk, out var sk);
model.PublicKey = pk;
}
}
return(base.BeforeSave(model, out error));
}
public async Task Returns_ok_given_valid_hashprefix()
{
string validHashPrefix = "ABCDE";
var returnHashFile = new PwnedPasswordsFile(Stream.Null, DateTimeOffset.UtcNow, "*");
var mockStorage = new Mock <IFileStorage>();
mockStorage.Setup(s => s.GetHashFileAsync(validHashPrefix, CancellationToken.None)).ReturnsAsync(returnHashFile);
var function = new Functions.Range(s_nullLogger, mockStorage.Object);
var context = new DefaultHttpContext();
IActionResult?actualResponse = await function.RunAsync(context.Request, validHashPrefix);
Assert.IsType <FileStreamResult>(actualResponse);
}
public async Task Returns_notfound_if_hashprefix_doesnt_exist()
{
var mockStorage = new Mock <IFileStorage>();
mockStorage.Setup(s => s.GetHashFileAsync(It.IsAny <string>(), CancellationToken.None)).ThrowsAsync(new FileNotFoundException());
var function = new Functions.Range(s_nullLogger, mockStorage.Object);
var context = new DefaultHttpContext();
IActionResult?actualResponse = await function.RunAsync(context.Request, "ABCDE");
ContentResult?result = Assert.IsType <ContentResult>(actualResponse);
Assert.Equal(StatusCodes.Status404NotFound, result.StatusCode);
}
public async Task Returns_bad_request_given_invalid_hashprefix(string invalidHashPrefix)
{
var mockStorage = new Mock <IFileStorage>();
mockStorage.Setup(s => s.GetHashFileAsync(It.IsAny <string>(), CancellationToken.None)).ReturnsAsync(default(PwnedPasswordsFile));
var function = new Functions.Range(s_nullLogger, mockStorage.Object);
var context = new DefaultHttpContext();
IActionResult?actualResponse = await function.RunAsync(context.Request, invalidHashPrefix);
ContentResult?result = Assert.IsType <ContentResult>(actualResponse);
Assert.Equal(StatusCodes.Status400BadRequest, result.StatusCode);
}
public async Task Returns_internal_server_error_when_something_goes_wrong()
{
var mockStorage = new Mock <IFileStorage>();
mockStorage.Setup(s => s.GetHashFileAsync(It.IsAny <string>(), CancellationToken.None)).ThrowsAsync(new Exception());
var function = new Functions.Range(s_nullLogger, mockStorage.Object);
var context = new DefaultHttpContext();
IActionResult?actualResponse = await function.RunAsync(context.Request, "ABCDE");
ContentResult?result = Assert.IsType <ContentResult>(actualResponse);
Assert.Equal(StatusCodes.Status500InternalServerError, result.StatusCode);
}
/// <summary>
/// Customer was created.
/// </summary>
/// <param name="output">Output.</param>
public void Standard(RegisterOutput output)
{
var customerModel = new CustomerModel((Customer)output.Customer);
var accountsModel =
(from Account accountEntity in output.Accounts
select new AccountModel(accountEntity))
.ToList();
var registerResponse = new RegisterResponse(customerModel, accountsModel);
this.ViewModel = new CreatedAtRouteResult(
"GetCustomer",
new { customerId = registerResponse.Customer.CustomerId, version = "1.0" },
registerResponse);
}
public GenericResultRecord(TValidResult?validResult, IActionResult?failedResult)
{
if (validResult is null && failedResult is null)
{
throw new Exception("Both results cannot be null");
}
if (validResult is not null && failedResult is not null)
{
throw new Exception("One result must be null.");
}
ValidResult = validResult;
FailedResult = failedResult;
}
public static bool TryParseBasicAuthentication(string authorization,
[NotNullWhen(false)] out IActionResult?failure,
[NotNullWhen(true)] out string?username,
[NotNullWhen(true)] out string?password)
{
username = null;
password = null;
if (!authorization.StartsWith("Basic "))
{
failure = new UnauthorizedResult();
return(false);
}
var split = Base64Util.Utf8Base64ToString(authorization[6..]).Split(':');
private static void Validate(int statusCode, IActionResult?actionResult, Exception?exception)
{
var result = actionResult as ObjectResult;
var error = result?.Value as ErrorDto;
Assert.NotNull(error?.Type);
Assert.Equal(statusCode, result?.StatusCode);
Assert.Equal(statusCode, error?.StatusCode);
if (exception != null)
{
Assert.Equal(exception.Message, error?.Message);
}
}
public void OnException(ExceptionContext context)
{
IActionResult?result = null;
foreach (var handler in Handlers)
{
result = handler(context.Exception);
if (result != null)
{
break;
}
}
if (result != null)
{
context.Result = result;
}
}
public static void AfterHandlerMethod(
this DiagnosticListener diagnosticListener,
ActionContext actionContext,
HandlerMethodDescriptor handlerMethodDescriptor,
IReadOnlyDictionary <string, object?> arguments,
object instance,
IActionResult?result)
{
Debug.Assert(diagnosticListener != null);
Debug.Assert(actionContext != null);
Debug.Assert(handlerMethodDescriptor != null);
Debug.Assert(arguments != null);
Debug.Assert(instance != null);
// Inlinable fast-path check if Diagnositcs is enabled
if (diagnosticListener.IsEnabled())
{
AfterHandlerMethodImpl(diagnosticListener, actionContext, handlerMethodDescriptor, arguments, instance, result);
}
}
public IActionResult OnGet(string?reference, string?show = null)
{
IActionResult?actionResult = null;
if (reference != null)
{
reference = reference.ToUpper();
foreach (var linkInfo in _linkInfoList)
{
if (linkInfo.Reference == reference)
{
if (linkInfo.HttpsAvailable)
{
actionResult = Redirect("https:" + linkInfo.Uri);
}
else
{
actionResult = Redirect("http:" + linkInfo.Uri);
}
break;
}
}
}
if (string.Equals(show, "All", StringComparison.OrdinalIgnoreCase))
{
ShowAll = true;
}
if (actionResult == null)
{
LinkInfoList = _linkInfoList;
actionResult = Page();
}
return(actionResult);
}
void IOutputPort.Ok(Account account)
{
using DataTable dataTable = new DataTable();
dataTable.Columns.Add("AccountId", typeof(Guid));
dataTable.Columns.Add("Amount", typeof(decimal));
dataTable.Rows.Add(account.AccountId.Id, account.GetCurrentBalance().Amount);
byte[] fileContents;
using (ExcelPackage pck = new ExcelPackage())
{
ExcelWorksheet ws = pck.Workbook.Worksheets.Add(account.AccountId.ToString());
ws.Cells["A1"].LoadFromDataTable(dataTable, true);
ws.Row(1).Style.Font.Bold = true;
ws.Column(3).Style.Numberformat.Format = "dd/MM/yyyy HH:mm";
fileContents = pck.GetAsByteArray();
}
this._viewModel = new FileContentResult(fileContents,
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}
void IOutputPort.Ok(Account account) => this._viewModel = this.Ok(new GetAccountResponse(account));
void IOutputPort.NotFound() => this._viewModel = this.NotFound();
void IOutputPort.Invalid(Notification notification)
{
ValidationProblemDetails problemDetails = new ValidationProblemDetails(notification.ModelState);
this._viewModel = this.BadRequest(problemDetails);
}
/// <summary>
/// Produz o resultado bad request 400, de forma amigável
/// </summary>
/// <param name="errors">Coleção de erros de validação de dados.</param>
public void WriteError(IReadOnlyCollection <Flunt.Notifications.Notification> errors)
{
var erros = new Models.ErrorModel(errors);
this.ViewModel = new BadRequestObjectResult(erros);
}
/// <summary> /// Produz o resultado bad request 400, de forma amigável /// </summary> /// <param name="message">Output da rota.</param> public void WriteError(string message) => this.ViewModel = new BadRequestObjectResult(message);
/// <summary> /// Produz o resultado de sucesso do endpoint. /// </summary> /// <param name="output">Output da rota.</param> public void Success(ProdutoOutput output) => this.ViewModel = new OkObjectResult(output);