public async Task <ActionResult <CurrentUserDto> > GetYourInfo(CancellationToken cancellationToken)
{
var result = await _mediator.Send(new GetCurrentUserQuery(_currentUserId), cancellationToken);
return(result != null
? Ok(result)
: Unauthorized(ErrorApiResponse.Unauthorized()));
}
public async Task <ActionResult <ProfileDto> > GetUser(string username, CancellationToken cancellationToken)
{
var result = await _mediator.Send(new GetProfileQuery(username), cancellationToken);
return(result != null
? Ok(result)
: NotFound(ErrorApiResponse.NotFound("User was not found.")));
}
public static ActionResult ReturnErrorResponse(this Result result)
{
var response = new ErrorApiResponse(result.ToErrorCode(), result.Message, result.Errors);
return(new ObjectResult(response)
{
StatusCode = response.Code
});
}
public async Task <ActionResult <AudioDto> > Get([FromRoute] string slug, CancellationToken cancellationToken)
{
// Decode hash into audio id
var id = HashIdHelper.DecodeLong(slug);
var result = await _mediator.Send(new GetAudioQuery(id), cancellationToken);
return(result != null
? new JsonResult(result)
: NotFound(ErrorApiResponse.NotFound("Audio was not found.")));
}
protected override async Task HandleChallengeAsync(AuthenticationProperties properties)
{
await base.HandleChallengeAsync(properties);
if (_key != null)
{
var errorResponse = new ErrorApiResponse("Deactivated");
Context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
await Context.CreateResponse(errorResponse);
}
}
public override Task ReturnQuotaExceededResponse(HttpContext httpContext, RateLimitRule rule, string retryAfter)
{
var message = string.Format(_rateLimitOptions.QuotaExceededResponse.Content, retryAfter);
if (!_rateLimitOptions.DisableRateLimitHeaders)
{
httpContext.Response.Headers["Retry-After"] = (StringValues)retryAfter;
}
var code = _rateLimitOptions.QuotaExceededResponse?.StatusCode ?? _rateLimitOptions.HttpStatusCode;
var contentType = _rateLimitOptions.QuotaExceededResponse?.ContentType ?? "text/plain";
var response = new ErrorApiResponse(code, message, null);
httpContext.Response.StatusCode = code;
httpContext.Response.ContentType = contentType;
return(httpContext.Response.WriteAsync(JsonSerializer.Serialize(response)));
}
public static IServiceCollection ConfigureAuthentication(this IServiceCollection services, IConfiguration configuration,
IWebHostEnvironment environment)
{
services.AddSingleton <ITicketStore, DistributedCacheTicketStore>();
services.AddOptions <CookieAuthenticationOptions>(CookieAuthenticationDefaults.AuthenticationScheme)
.Configure <ITicketStore>((options, ticketStore) =>
{
options.Cookie.Name = "auth.cookie";
options.SessionStore = ticketStore;
options.Cookie.SameSite = environment.IsProduction()
? SameSiteMode.Lax
: SameSiteMode.Unspecified;
options.Cookie.SecurePolicy = environment.IsProduction()
? CookieSecurePolicy.Always
: CookieSecurePolicy.None;
options.Events.OnRedirectToLogin = async context =>
{
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
var response = ErrorApiResponse.Unauthorized();
await context.Response.WriteAsJsonAsync(response);
await context.Response.Body.FlushAsync();
};
options.Events.OnRedirectToAccessDenied = async context =>
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
var response = ErrorApiResponse.Forbidden();
await context.Response.WriteAsJsonAsync(response);
await context.Response.Body.FlushAsync();
};
});
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme).AddCookie();
services.AddTransient <ICurrentUserService, CurrentUserService>();
return(services);
}
public void OnException(ExceptionContext context)
{
_logger.LogError(context.Exception.Message, context.Exception.StackTrace);
var errorModel = new ErrorApiResponse();
if (_exceptionTypeStatusCodes.ContainsKey(context.Exception.GetType()))
{
context.HttpContext.Response.StatusCode = (int)_exceptionTypeStatusCodes[context.Exception.GetType()];
errorModel.Message = context.Exception.Message;
}
else
{
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
errorModel.UnhandledException = true;
errorModel.Message = "An Error has occured";
}
errorModel.Exception = context.Exception.GetDeepestMessage();
context.Result = new ObjectResult(errorModel);
context.ExceptionHandled = true;
}
private async Task HandleException(HttpContext context, Exception ex)
{
_logger.LogError(ex, ex.Message);
ErrorApiResponse response;
switch (ex)
{
case ValidationException vex:
response = ErrorApiResponse.Invalid(vex.Errors);
break;
default:
var message = _env.IsDevelopment()
? ex.Message
: "An unexpected error has occurred.";
response = new ErrorApiResponse(StatusCodes.Status500InternalServerError, message, null);
break;
}
context.Response.StatusCode = response.Code;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(JsonSerializer.Serialize(response, _jsonOptions));
}
public TextSplitApiErrorException(string message, ErrorApiResponse error) : base(message)
{
Error = error;
}
