🐞Handle Response

Nuget package: https://www.nuget.org/packages/TieuAnhQuoc.HandleResponse/

Github: https://github.com/tieuanhquoc/Library/tree/master/TieuAnhQuoc.HandleResponse

ApiException.cs

ApiException.cs

[Serializable]
public class ApiException : Exception
{
    protected ApiException(SerializationInfo serializationInfo, StreamingContext streamingContext) : base(
        serializationInfo, streamingContext)
    {
    }

    public ApiException(string message, StatusCode statusCode) : base(message)
    {
        StatusCode = statusCode;
        Message = string.IsNullOrEmpty(message) ? StatusCode.ToString() : message;
    }

    public ApiException(string message, StatusCode statusCode, object result) : base(message)
    {
        StatusCode = statusCode;
        Message = string.IsNullOrEmpty(message) ? StatusCode.ToString() : message;
        Data = result;
    }

    public ApiException(StatusCode statusCode) : base(statusCode.ToString())
    {
        StatusCode = statusCode;
        Message = MessageKey.ServerError;
    }

    public ApiException(string message) : base(message)
    {
        StatusCode = StatusCode.SERVER_ERROR;
        Message = string.IsNullOrEmpty(message) ? StatusCode.ToString() : message;
    }

    public ApiException() : base(StatusCode.SERVER_ERROR.ToString())
    {
    }

    public StatusCode StatusCode { get; set; } = StatusCode.SERVER_ERROR;
    public override string Message { get; } = MessageKey.ServerError;
    public new object Data { get; }
}

public enum StatusCode
{
    SUCCESS = 200,
    CREATED = 201,
    BAD_REQUEST = 400,
    UNAUTHORIZED = 401,
    FORBIDDEN = 403,
    NOT_FOUND = 404,
    NOT_ACTIVE = 405,
    CHANGE_PASSWORD = 406,
    NOT_VERIFY = 407,
    TIME_OUT = 408,
    ALREADY_EXISTS = 409,
    UNPROCESSABLE_ENTITY = 422,
    SERVER_ERROR = 500,
}

public class MessageKey
{
    public const string BadRequest = "system_message_bad_request";
    public const string Unauthorized = "system_message_unauthorized";
    public const string Forbidden = "system_message_forbidden";
    public const string NotActive = "system_message_not_active";
    public const string ChooseFile = "system_message_choose_file";
    public const string NotFound = "system_message_not_found";
    public const string AlreadyExists = "system_message_already_exists";
    public const string ServerError = "system_message_server_error";
    public const string TokenNotFound = "system_message_token_not_found";
    public const string TokenIncorrect = "system_message_token_incorrect";
    public const string TokenExpired = "system_message_token_expired";
    public const string TokenIsStillValid = "system_message_token_is_still_valid";
}

ApiResponse.cs

ApiResponse.cs

public class ApiResponse<T> : ApiResponse
{
    public T Data { get; set; }

    public static ApiResponse<T> Success(T result)
    {
        return Create(result, StatusCode.SUCCESS, StatusCode.SUCCESS.ToString());
    }

    private static ApiResponse<T> Create(T data, StatusCode statusCode, string message)
    {
        return new ApiResponse<T>
        {
            Data = data,
            StatusCode = statusCode,
            Message = message,
        };
    }
}

public class ApiResponses<T> : ApiResponse
{
    public int? TotalCount { get; set; } = 0;
    public int? PageSize { get; set; } = 0;
    public int? Offset { get; set; } = 0;
    public int? TotalPages { get; set; } = 0;
    public IEnumerable<T> Data { get; set; }

    public static ApiResponses<T> Success(IEnumerable<T> data, int? totalCount = null, int? pageSize = null,
        int? offset = null,
        int? totalPages = null)
    {
        return Create(
            data,
            StatusCode.SUCCESS,
            StatusCode.SUCCESS.ToString(),
            totalCount,
            pageSize,
            offset,
            totalPages
        );
    }

    private static ApiResponses<T> Create(IEnumerable<T> data, StatusCode statusCode, string message,
        int? totalCount,
        int? pageSize,
        int? offset,
        int? totalPages)
    {
        return new ApiResponses<T>
        {
            Data = data,
            StatusCode = statusCode,
            Message = message,
            TotalCount = totalCount,
            PageSize = pageSize,
            Offset = offset,
            TotalPages = totalPages
        };
    }
}

public class ApiResponse
{
    public StatusCode StatusCode { get; set; }

    public string Message { get; set; }

    public static ApiResponse Success()
    {
        return Created(StatusCode.SUCCESS, "Success");
    }

    public static ApiResponse Success(string message)
    {
        return Created(StatusCode.SUCCESS, message);
    }

    public static ApiResponse Failed()
    {
        return Created(StatusCode.BAD_REQUEST, "Failed");
    }

    public static ApiResponse Created(StatusCode statusCode, string message)
    {
        return new ApiResponse
        {
            StatusCode = statusCode,
            Message = message,
        };
    }

    public static ApiResponse Created(string message)
    {
        return new ApiResponse
        {
            StatusCode = StatusCode.CREATED,
            Message = message,
        };
    }
}

HandleResponseMiddleware.cs

HandleResponseMiddleware.cs

public class HandleResponseMiddleware
{
    private readonly RequestDelegate _next;

    public HandleResponseMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var ignorePath = (Environment.GetEnvironmentVariable("IGNORE_LOG_PATH") ?? string.Empty)
            .Replace(" ", "")
            .Split(",")
            .ToList();
        if (!ignorePath.Contains(context.Request.Path))
        {
            var startTime = Stopwatch.GetTimestamp();
            try
            {
                await _next(context);
                var elapsedMilliseconds = GetElapsedMilliseconds(startTime, Stopwatch.GetTimestamp());
                Log.Information(
                    "Http Response Information | Method: {Method} | Path: {Path} | Status Code: {StatusCode} | QueryString: {QueryString}",
                    context.Request.Method.ToUpper(),
                    context.Request.Path,
                    $"{context.Response.StatusCode} in {elapsedMilliseconds} ms",
                    context.Request.QueryString
                );
            }
            catch (ApiException apiException)
            {
                var elapsedMilliseconds = GetElapsedMilliseconds(startTime, Stopwatch.GetTimestamp());
                var resultException = new ApiException(
                    apiException.Message,
                    apiException.StatusCode, apiException.Data);
                Log.Error(apiException.StackTrace ?? string.Empty);
                await HandleExceptionAsync(
                    context,
                    resultException,
                    resultException,
                    elapsedMilliseconds
                );
            }
            catch (DbUpdateException exception)
            {
                var elapsedMilliseconds = GetElapsedMilliseconds(startTime, Stopwatch.GetTimestamp());
                if (exception.InnerException?.Data["SqlState"]?.ToString() == "23505")
                {
                    var table = exception.InnerException?.Data["TableName"]?.ToString() ?? string.Empty;
                    var column = exception.InnerException?.Data["ConstraintName"]?.ToString() ?? string.Empty;
                    var index = column.LastIndexOf("_", StringComparison.InvariantCultureIgnoreCase);
                    index = index > 0 ? index + 1 : index;
                    column = column[index..];
                    await HandleExceptionAsync(
                        context,
                        new ApiException
                        (
                            $"Column {column} ({table}) has duplicated",
                            StatusCode.ALREADY_EXISTS
                        ),
                        exception,
                        elapsedMilliseconds
                    );
                }
                else
                {
                    await HandleExceptionAsync(context, new ApiException(), exception, elapsedMilliseconds);
                }

                if (exception is DbUpdateConcurrencyException)
                {
                    var entry = exception.Entries.Single();
                    var databaseValues = entry.GetDatabaseValues().ToObject();
                    var clientValues = entry.Entity;

                    await HandleExceptionAsync(
                        context,
                        new ApiException
                        (
                            StatusCode.UNPROCESSABLE_ENTITY
                        ),
                        exception,
                        elapsedMilliseconds
                    );
                }
            }
            catch (Exception exception)
            {
                var elapsedMilliseconds = GetElapsedMilliseconds(startTime, Stopwatch.GetTimestamp());
                await HandleExceptionAsync(context, new ApiException(), exception, elapsedMilliseconds);
            }
        }
        else
        {
            await _next(context);
        }
    }

    private static async Task HandleExceptionAsync(HttpContext context, ApiException apiException, Exception exception,
        double elapsedMilliseconds)
    {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int)apiException.StatusCode;
        await context.Response.WriteAsJsonAsync(
            new
            {
                Message = apiException.Message,
                statusCode = apiException.StatusCode,
                result = apiException.Data
            }, new JsonSerializerOptions
            {
                PropertyNamingPolicy = new SnakeCaseNamingPolicy(),
                PropertyNameCaseInsensitive = true,
                ReferenceHandler = ReferenceHandler.IgnoreCycles,
                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
            }
        );


        IEnumerable<LogEventProperty> properties = new LogEventProperty[]
        {
            new("RequestMethod", new ScalarValue(context.Request.Method.ToUpper())),
            new("RequestPath", new ScalarValue(context.Request.Path)),
            new("StatusCode", new ScalarValue(context.Response.StatusCode)),
            new("Elapsed", new ScalarValue(elapsedMilliseconds)),
            new("Message",
                new ScalarValue(apiException.Message))
        };
        var messageTemplate = new MessageTemplateParser().Parse(
            "Http Response - Method: {RequestMethod} | Path: {RequestPath} | Responded {StatusCode} in {Elapsed:0.0000} ms | Message: {Message}");
        var logEvent = new LogEvent(
            DateTimeOffset.Now,
            LogEventLevel.Error,
            exception,
            messageTemplate,
            properties
        );
        Log.Write(logEvent);
    }

    private static double GetElapsedMilliseconds(long start, long stop) =>
        (stop - start) * 1000L / (double)Stopwatch.Frequency;
}

Readme.md

#### Add setting
    app.UseMiddleware<HandleResponseMiddleware>();

#### Use ApiResponse
    return ApiResponse.Success("Message");
    return ApiResponse<ResponseObject>.Success(responseObject);

#### Use ApiResponses
    return return ApiResponses<ResponseObject>.Success(responseObjects, totalRow, pageSize, offset, totalPage);