<form method="POST">
    <h3>Editing: ApiResponse.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace CarouselSlider\Traits;

use WP_Error;
use WP_REST_Response;

trait ApiResponse {

	/**
	 * HTTP status code
	 *
	 * @var int
	 */
	protected $status_code = 200;

	/**
	 * The error code
	 *
	 * @var string
	 */
	protected $error_code = null;

	/**
	 * The message
	 *
	 * @var string
	 */
	protected $message = null;

	/**
	 * The data to be sent over HTTP
	 *
	 * @var mixed
	 */
	protected $data = null;

	/**
	 * Additional headers for response
	 *
	 * @var array
	 */
	protected $headers = [];

	/**
	 * Decode HTML entity
	 * WordPress encode html entity when saving on database.
	 * Convert then back to character before sending data
	 *
	 * @param mixed $value The value to be decoded.
	 *
	 * @return mixed
	 */
	public function html_entity_decode( $value ) {
		if ( ! is_string( $value ) ) {
			return $value;
		}

		return html_entity_decode( $value, ENT_QUOTES | ENT_HTML5, get_option( 'blog_charset', 'UTF-8' ) );
	}

	/**
	 * Get HTTP status code.
	 *
	 * @return integer
	 */
	public function get_status_code(): int {
		return $this-&gt;status_code;
	}

	/**
	 * Set HTTP status code.
	 *
	 * @param int $status_code The http status code.
	 *
	 * @return static
	 */
	public function set_status_code( int $status_code ) {
		$this-&gt;status_code = $status_code;

		return $this;
	}

	/**
	 * If it has error code
	 *
	 * @return bool
	 */
	public function has_error_code(): bool {
		return ! empty( $this-&gt;get_error_code() );
	}

	/**
	 * Get error code
	 *
	 * @return string
	 */
	public function get_error_code(): string {
		if ( is_string( $this-&gt;error_code ) &amp;&amp; ! empty( $this-&gt;error_code ) ) {
			return $this-&gt;error_code;
		}
		$default = $this-&gt;get_default_error_message();

		return $default['code'] ?? '';
	}

	/**
	 * Set error code
	 *
	 * @param string|null $error_code The error code string.
	 */
	public function set_error_code( $error_code ) {
		if ( is_string( $error_code ) &amp;&amp; ! empty( $error_code ) ) {
			$this-&gt;error_code = $error_code;
		}

		return $this;
	}

	/**
	 * If it has a message
	 *
	 * @return bool
	 */
	public function has_message(): bool {
		return ! empty( $this-&gt;get_message() );
	}

	/**
	 * Get message
	 *
	 * @return string
	 */
	public function get_message(): string {
		if ( is_string( $this-&gt;message ) &amp;&amp; ! empty( $this-&gt;message ) ) {
			return $this-&gt;message;
		}
		$default = $this-&gt;get_default_error_message();

		return $default['message'] ?? '';
	}

	/**
	 * Set message
	 *
	 * @param string|null $message The message string.
	 */
	public function set_message( $message ) {
		if ( is_string( $message ) &amp;&amp; ! empty( $message ) ) {
			$this-&gt;message = $message;
		}

		return $this;
	}

	/**
	 * If it has data
	 *
	 * @return bool
	 */
	public function has_data(): bool {
		return ! empty( $this-&gt;data );
	}

	/**
	 * Get data
	 *
	 * @return mixed
	 */
	public function get_data() {
		return $this-&gt;data;
	}

	/**
	 * Set data
	 *
	 * @param mixed $data The data for HTTP response body.
	 */
	public function set_data( $data ) {
		if ( ! empty( $data ) ) {
			$this-&gt;data = $data;
		}

		return $this;
	}

	/**
	 * Get additional response headers
	 *
	 * @return array
	 */
	public function get_headers(): array {
		return $this-&gt;headers;
	}

	/**
	 * Set additional response header
	 *
	 * @param array $headers Additional headers.
	 *
	 * @return static
	 */
	public function set_headers( array $headers ) {
		foreach ( $headers as $key =&gt; $value ) {
			$this-&gt;headers[ $key ] = $value;
		}

		return $this;
	}

	/**
	 * Check if it is a success response
	 *
	 * @return bool
	 */
	public function is_success_response(): bool {
		return ( $this-&gt;get_status_code() &gt;= 200 &amp;&amp; $this-&gt;get_status_code() &lt; 300 );
	}

	/**
	 * Get default error message
	 *
	 * @return array
	 */
	protected function get_default_error_message(): array {
		$messages = [
			401 =&gt; [
				'code'    =&gt; 'rest_forbidden_context',
				'message' =&gt; __( 'Sorry, you are not allowed to access this resource.', 'carousel-slider' ),
			],
			403 =&gt; [
				'code'    =&gt; 'rest_forbidden_context',
				'message' =&gt; __( 'Sorry, you are not allowed to access this resource.', 'carousel-slider' ),
			],
			404 =&gt; [
				'code'    =&gt; 'rest_no_item_found',
				'message' =&gt; __( 'Sorry, no item found for your request.', 'carousel-slider' ),
			],
			422 =&gt; [
				'code'    =&gt; 'rest_invalid_data_type',
				'message' =&gt; __( 'One or more fields has an error. Fix and try again.', 'carousel-slider' ),
			],
			500 =&gt; [
				'code'    =&gt; 'rest_server_error',
				'message' =&gt; __( 'Sorry, something went wrong.', 'carousel-slider' ),
			],
		];

		return $messages[ $this-&gt;get_status_code() ] ?? [
			'code'    =&gt; null,
			'message' =&gt; null,
		];
	}

	/**
	 * Get formatted response
	 *
	 * @return array
	 */
	protected function get_formatted_response(): array {
		$response = [
			'success' =&gt; $this-&gt;is_success_response(),
		];

		if ( $this-&gt;has_error_code() ) {
			$response['code'] = $this-&gt;get_error_code();
		}

		if ( $this-&gt;has_message() ) {
			$response['message'] = $this-&gt;get_message();
		}

		if ( $this-&gt;has_data() ) {
			if ( ! $this-&gt;is_success_response() ) {
				$response['errors'] = $this-&gt;get_data();
			} else {
				$response['data'] = is_array( $this-&gt;get_data() ) ?
					map_deep( $this-&gt;get_data(), [ $this, 'html_entity_decode' ] ) :
					$this-&gt;get_data();
			}
		}

		return $response;
	}

	/**
	 * Respond.
	 *
	 * @param mixed $data Response data. Default null.
	 * @param int   $status Optional. HTTP status code. Default 200.
	 * @param array $headers Optional. HTTP header map. Default empty array.
	 *
	 * @return WP_REST_Response
	 */
	public function respond( $data = null, $status = null, $headers = [] ): WP_REST_Response {
		if ( empty( $data ) ) {
			$data = $this-&gt;get_formatted_response();
		}
		if ( empty( $status ) ) {
			$status = $this-&gt;get_status_code();
		}
		if ( empty( $headers ) ) {
			$headers = $this-&gt;get_headers();
		}

		return new WP_REST_Response( $data, $status, $headers );
	}

	/**
	 * Response with WP_Error object
	 *
	 * @param WP_Error $error The error object.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_with_wp_error( WP_Error $error ): WP_REST_Response {
		$this-&gt;set_message( $error-&gt;get_error_message() );
		$this-&gt;set_error_code( $error-&gt;get_error_code() );

		$error_data = $error-&gt;has_errors() &amp;&amp; is_array( $error-&gt;get_error_data() ) ? $error-&gt;get_error_data() : [];
		if ( isset( $error_data['status'] ) ) {
			$status_code = is_numeric( $error_data['status'] ) ? intval( $error_data['status'] ) : 400;
			unset( $error_data['status'] );
		}

		if ( count( $error_data ) ) {
			$this-&gt;set_data( $error_data );
		}

		$this-&gt;set_status_code( $status_code ?? 400 );

		return $this-&gt;respond();
	}

	/**
	 * Response error message
	 *
	 * @param string|array|null $code The WP_Error object, or error data array, or error code string.
	 * @param string|null       $message The error message.
	 * @param mixed             $data Error data array.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_with_error( $code = null, $message = null, $data = null ): WP_REST_Response {
		if ( $code instanceof WP_Error ) {
			return $this-&gt;respond_with_wp_error( $code );
		}

		if ( 1 === func_num_args() &amp;&amp; is_array( $code ) ) {
			$this-&gt;set_data( $code );

			return $this-&gt;respond();
		}

		$this-&gt;set_error_code( $code );
		$this-&gt;set_message( $message );
		$this-&gt;set_data( $data );

		return $this-&gt;respond();
	}

	/**
	 * Response success message
	 *
	 * @param mixed       $data The response data. It Also can be set message if there is no data.
	 * @param string|null $message Additional message for the success response.
	 * @param array       $headers Additional http header.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_with_success( $data = null, $message = null, $headers = array() ): WP_REST_Response {
		if ( 1 === func_num_args() &amp;&amp; is_string( $data ) ) {
			list( $data, $message ) = array( null, $data );
		}

		$this-&gt;set_data( $data );
		$this-&gt;set_message( $message );
		$this-&gt;set_headers( $headers );

		return $this-&gt;respond();
	}

	/**
	 * 200 (OK)
	 * The request has succeeded.
	 * Use cases:
	 * --&gt; update/retrieve data
	 * --&gt; bulk creation
	 * --&gt; bulk update
	 *
	 * @param mixed       $data The data to be sent for response.
	 * @param string|null $message Response message (Optional).
	 *
	 * @return WP_REST_Response
	 */
	public function respond_ok( $data = null, $message = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 200 )-&gt;respond_with_success( $data, $message );
	}

	/**
	 * 201 (Created)
	 * The request has succeeded and a new resource has been created as a result of it.
	 * This is typically the response sent after a POST request, or after some PUT requests.
	 *
	 * @param mixed       $data The data to be sent for response.
	 * @param string|null $message Response message (Optional).
	 *
	 * @return WP_REST_Response
	 */
	public function respond_created( $data = null, $message = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 201 )-&gt;respond_with_success( $data, $message );
	}

	/**
	 * 202 (Accepted)
	 * The request has been received but not yet acted upon.
	 * The response should include the Location header with a link towards the location where
	 * the final response can be polled &amp; later obtained.
	 * Use cases:
	 * --&gt; asynchronous tasks (e.g., report generation)
	 * --&gt; batch processing
	 * --&gt; delete data that is NOT immediate
	 *
	 * @param mixed       $data The data to be sent for response.
	 * @param string|null $message Response message (Optional).
	 *
	 * @return WP_REST_Response
	 */
	public function respond_accepted( $data = null, $message = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 202 )-&gt;respond_with_success( $data, $message );
	}

	/**
	 * 204 (No Content)
	 * There is no content to send for this request, but the headers may be useful.
	 * Use cases:
	 * --&gt; deletion succeeded
	 *
	 * @param mixed       $data The data to be sent for response.
	 * @param string|null $message Response message (Optional).
	 *
	 * @return WP_REST_Response
	 */
	public function respond_no_content( $data = null, $message = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 204 )-&gt;respond_with_success( $data, $message );
	}

	/**
	 * 400 (Bad request)
	 * Server could not understand the request due to invalid syntax.
	 * Use cases:
	 * --&gt; invalid/incomplete request
	 * --&gt; return multiple client errors at once
	 *
	 * @param string|null $code The WP_Error object, or error code string.
	 * @param string|null $message The error message.
	 * @param mixed       $data Additional error data.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_bad_request( $code = null, $message = null, $data = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 400 )-&gt;respond_with_error( $code, $message, $data );
	}

	/**
	 * 401 (Unauthorized)
	 * The request requires user authentication.
	 *
	 * @param string|null $code The WP_Error object, or error code string.
	 * @param string|null $message The error message.
	 * @param mixed       $data Additional error data.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_unauthorized( $code = null, $message = null, $data = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 401 )-&gt;respond_with_error( $code, $message, $data );
	}

	/**
	 * 403 (Forbidden)
	 * The client is authenticated but not authorized to perform the action.
	 *
	 * @param string|null $code The WP_Error object, or error code string.
	 * @param string|null $message The error message.
	 * @param mixed       $data Additional error data.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_forbidden( $code = null, $message = null, $data = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 403 )-&gt;respond_with_error( $code, $message, $data );
	}

	/**
	 * 404 (Not Found)
	 * The server can not find requested resource. In an API, this can also mean that the endpoint is valid but
	 * the resource itself does not exist. Servers may also send this response instead of 403 to hide
	 * the existence of a resource from an unauthorized client.
	 *
	 * @param string|null $code The WP_Error object, or error code string.
	 * @param string|null $message The error message.
	 * @param mixed       $data Additional error data.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_not_found( $code = null, $message = null, $data = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 404 )-&gt;respond_with_error( $code, $message, $data );
	}

	/**
	 * 422 (Unprocessable Entity)
	 * The request was well-formed but was unable to be followed due to semantic errors.
	 *
	 * @param string|null $code The WP_Error object, or error code string.
	 * @param string|null $message The error message.
	 * @param mixed       $data Additional error data.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_unprocessable_entity( $code = null, $message = null, $data = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 422 )-&gt;respond_with_error( $code, $message, $data );
	}

	/**
	 * 500 (Internal Server Error)
	 * The server has encountered a situation it doesn't know how to handle.
	 *
	 * @param string|null $code The WP_Error object, or error code string.
	 * @param string|null $message The error message.
	 * @param mixed       $data Additional error data.
	 *
	 * @return WP_REST_Response
	 */
	public function respond_internal_server_error( $code = null, $message = null, $data = null ): WP_REST_Response {
		return $this-&gt;set_status_code( 500 )-&gt;respond_with_error( $code, $message, $data );
	}
}
</textarea><br>
    <input type="submit" value="Save">
</form>