?<h3>D¨ızenle: class-wp-rest-comments-controller.php</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>&lt;?php
/**
 * REST API: WP_REST_Comments_Controller class
 *
 * @package WordPress
 * @subpackage REST_API
 * @since 4.7.0
 */

/**
 * Core controller used to access comments via the REST API.
 *
 * @since 4.7.0
 *
 * @see WP_REST_Controller
 */
class WP_REST_Comments_Controller extends WP_REST_Controller {

	/**
	 * Instance of a comment meta fields object.
	 *
	 * @since 4.7.0
	 * @var WP_REST_Comment_Meta_Fields
	 */
	protected $meta;

	/**
	 * Constructor.
	 *
	 * @since 4.7.0
	 */
	public function __construct() {
		$this-&gt;namespace = &#039;wp/v2&#039;;
		$this-&gt;rest_base = &#039;comments&#039;;

		$this-&gt;meta = new WP_REST_Comment_Meta_Fields();
	}

	/**
	 * Registers the routes for comments.
	 *
	 * @since 4.7.0
	 *
	 * @see register_rest_route()
	 */
	public function register_routes() {

		register_rest_route(
			$this-&gt;namespace,
			&#039;/&#039; . $this-&gt;rest_base,
			array(
				array(
					&#039;methods&#039;             =&gt; WP_REST_Server::READABLE,
					&#039;callback&#039;            =&gt; array( $this, &#039;get_items&#039; ),
					&#039;permission_callback&#039; =&gt; array( $this, &#039;get_items_permissions_check&#039; ),
					&#039;args&#039;                =&gt; $this-&gt;get_collection_params(),
				),
				array(
					&#039;methods&#039;             =&gt; WP_REST_Server::CREATABLE,
					&#039;callback&#039;            =&gt; array( $this, &#039;create_item&#039; ),
					&#039;permission_callback&#039; =&gt; array( $this, &#039;create_item_permissions_check&#039; ),
					&#039;args&#039;                =&gt; $this-&gt;get_endpoint_args_for_item_schema( WP_REST_Server::CREATABLE ),
				),
				&#039;schema&#039; =&gt; array( $this, &#039;get_public_item_schema&#039; ),
			)
		);

		register_rest_route(
			$this-&gt;namespace,
			&#039;/&#039; . $this-&gt;rest_base . &#039;/(?P&lt;id&gt;[\d]+)&#039;,
			array(
				&#039;args&#039;   =&gt; array(
					&#039;id&#039; =&gt; array(
						&#039;description&#039; =&gt; __( &#039;Unique identifier for the comment.&#039; ),
						&#039;type&#039;        =&gt; &#039;integer&#039;,
					),
				),
				array(
					&#039;methods&#039;             =&gt; WP_REST_Server::READABLE,
					&#039;callback&#039;            =&gt; array( $this, &#039;get_item&#039; ),
					&#039;permission_callback&#039; =&gt; array( $this, &#039;get_item_permissions_check&#039; ),
					&#039;args&#039;                =&gt; array(
						&#039;context&#039;  =&gt; $this-&gt;get_context_param( array( &#039;default&#039; =&gt; &#039;view&#039; ) ),
						&#039;password&#039; =&gt; array(
							&#039;description&#039; =&gt; __( &#039;The password for the parent post of the comment (if the post is password protected).&#039; ),
							&#039;type&#039;        =&gt; &#039;string&#039;,
						),
					),
				),
				array(
					&#039;methods&#039;             =&gt; WP_REST_Server::EDITABLE,
					&#039;callback&#039;            =&gt; array( $this, &#039;update_item&#039; ),
					&#039;permission_callback&#039; =&gt; array( $this, &#039;update_item_permissions_check&#039; ),
					&#039;args&#039;                =&gt; $this-&gt;get_endpoint_args_for_item_schema( WP_REST_Server::EDITABLE ),
				),
				array(
					&#039;methods&#039;             =&gt; WP_REST_Server::DELETABLE,
					&#039;callback&#039;            =&gt; array( $this, &#039;delete_item&#039; ),
					&#039;permission_callback&#039; =&gt; array( $this, &#039;delete_item_permissions_check&#039; ),
					&#039;args&#039;                =&gt; array(
						&#039;force&#039;    =&gt; array(
							&#039;type&#039;        =&gt; &#039;boolean&#039;,
							&#039;default&#039;     =&gt; false,
							&#039;description&#039; =&gt; __( &#039;Whether to bypass Trash and force deletion.&#039; ),
						),
						&#039;password&#039; =&gt; array(
							&#039;description&#039; =&gt; __( &#039;The password for the parent post of the comment (if the post is password protected).&#039; ),
							&#039;type&#039;        =&gt; &#039;string&#039;,
						),
					),
				),
				&#039;schema&#039; =&gt; array( $this, &#039;get_public_item_schema&#039; ),
			)
		);
	}

	/**
	 * Checks if a given request has access to read comments.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error True if the request has read access, error object otherwise.
	 */
	public function get_items_permissions_check( $request ) {

		if ( ! empty( $request[&#039;post&#039;] ) ) {
			foreach ( (array) $request[&#039;post&#039;] as $post_id ) {
				$post = get_post( $post_id );

				if ( ! empty( $post_id ) &amp;&amp; $post &amp;&amp; ! $this-&gt;check_read_post_permission( $post, $request ) ) {
					return new WP_Error(
						&#039;rest_cannot_read_post&#039;,
						__( &#039;Sorry, you are not allowed to read the post for this comment.&#039; ),
						array( &#039;status&#039; =&gt; rest_authorization_required_code() )
					);
				} elseif ( 0 === $post_id &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
					return new WP_Error(
						&#039;rest_cannot_read&#039;,
						__( &#039;Sorry, you are not allowed to read comments without a post.&#039; ),
						array( &#039;status&#039; =&gt; rest_authorization_required_code() )
					);
				}
			}
		}

		if ( ! empty( $request[&#039;context&#039;] ) &amp;&amp; &#039;edit&#039; === $request[&#039;context&#039;] &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
			return new WP_Error(
				&#039;rest_forbidden_context&#039;,
				__( &#039;Sorry, you are not allowed to edit comments.&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		if ( ! current_user_can( &#039;edit_posts&#039; ) ) {
			$protected_params = array( &#039;author&#039;, &#039;author_exclude&#039;, &#039;author_email&#039;, &#039;type&#039;, &#039;status&#039; );
			$forbidden_params = array();

			foreach ( $protected_params as $param ) {
				if ( &#039;status&#039; === $param ) {
					if ( &#039;approve&#039; !== $request[ $param ] ) {
						$forbidden_params[] = $param;
					}
				} elseif ( &#039;type&#039; === $param ) {
					if ( &#039;comment&#039; !== $request[ $param ] ) {
						$forbidden_params[] = $param;
					}
				} elseif ( ! empty( $request[ $param ] ) ) {
					$forbidden_params[] = $param;
				}
			}

			if ( ! empty( $forbidden_params ) ) {
				return new WP_Error(
					&#039;rest_forbidden_param&#039;,
					/* translators: %s: List of forbidden parameters. */
					sprintf( __( &#039;Query parameter not permitted: %s&#039; ), implode( &#039;, &#039;, $forbidden_params ) ),
					array( &#039;status&#039; =&gt; rest_authorization_required_code() )
				);
			}
		}

		return true;
	}

	/**
	 * Retrieves a list of comment items.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, or error object on failure.
	 */
	public function get_items( $request ) {

		// Retrieve the list of registered collection query parameters.
		$registered = $this-&gt;get_collection_params();

		/*
		 * This array defines mappings between public API query parameters whose
		 * values are accepted as-passed, and their internal WP_Query parameter
		 * name equivalents (some are the same). Only values which are also
		 * present in $registered will be set.
		 */
		$parameter_mappings = array(
			&#039;author&#039;         =&gt; &#039;author__in&#039;,
			&#039;author_email&#039;   =&gt; &#039;author_email&#039;,
			&#039;author_exclude&#039; =&gt; &#039;author__not_in&#039;,
			&#039;exclude&#039;        =&gt; &#039;comment__not_in&#039;,
			&#039;include&#039;        =&gt; &#039;comment__in&#039;,
			&#039;offset&#039;         =&gt; &#039;offset&#039;,
			&#039;order&#039;          =&gt; &#039;order&#039;,
			&#039;parent&#039;         =&gt; &#039;parent__in&#039;,
			&#039;parent_exclude&#039; =&gt; &#039;parent__not_in&#039;,
			&#039;per_page&#039;       =&gt; &#039;number&#039;,
			&#039;post&#039;           =&gt; &#039;post__in&#039;,
			&#039;search&#039;         =&gt; &#039;search&#039;,
			&#039;status&#039;         =&gt; &#039;status&#039;,
			&#039;type&#039;           =&gt; &#039;type&#039;,
		);

		$prepared_args = array();

		/*
		 * For each known parameter which is both registered and present in the request,
		 * set the parameter&#039;s value on the query $prepared_args.
		 */
		foreach ( $parameter_mappings as $api_param =&gt; $wp_param ) {
			if ( isset( $registered[ $api_param ], $request[ $api_param ] ) ) {
				$prepared_args[ $wp_param ] = $request[ $api_param ];
			}
		}

		// Ensure certain parameter values default to empty strings.
		foreach ( array( &#039;author_email&#039;, &#039;search&#039; ) as $param ) {
			if ( ! isset( $prepared_args[ $param ] ) ) {
				$prepared_args[ $param ] = &#039;&#039;;
			}
		}

		if ( isset( $registered[&#039;orderby&#039;] ) ) {
			$prepared_args[&#039;orderby&#039;] = $this-&gt;normalize_query_param( $request[&#039;orderby&#039;] );
		}

		$prepared_args[&#039;no_found_rows&#039;] = false;

		$prepared_args[&#039;update_comment_post_cache&#039;] = true;

		$prepared_args[&#039;date_query&#039;] = array();

		// Set before into date query. Date query must be specified as an array of an array.
		if ( isset( $registered[&#039;before&#039;], $request[&#039;before&#039;] ) ) {
			$prepared_args[&#039;date_query&#039;][0][&#039;before&#039;] = $request[&#039;before&#039;];
		}

		// Set after into date query. Date query must be specified as an array of an array.
		if ( isset( $registered[&#039;after&#039;], $request[&#039;after&#039;] ) ) {
			$prepared_args[&#039;date_query&#039;][0][&#039;after&#039;] = $request[&#039;after&#039;];
		}

		if ( isset( $registered[&#039;page&#039;] ) &amp;&amp; empty( $request[&#039;offset&#039;] ) ) {
			$prepared_args[&#039;offset&#039;] = $prepared_args[&#039;number&#039;] * ( absint( $request[&#039;page&#039;] ) - 1 );
		}

		$is_head_request = $request-&gt;is_method( &#039;HEAD&#039; );
		if ( $is_head_request ) {
			// Force the &#039;fields&#039; argument. For HEAD requests, only post IDs are required to calculate pagination.
			$prepared_args[&#039;fields&#039;] = &#039;ids&#039;;
			// Disable priming comment meta for HEAD requests to improve performance.
			$prepared_args[&#039;update_comment_meta_cache&#039;] = false;
		}

		/**
		 * Filters WP_Comment_Query arguments when querying comments via the REST API.
		 *
		 * @since 4.7.0
		 *
		 * @link https://developer.wordpress.org/reference/classes/wp_comment_query/
		 *
		 * @param array           $prepared_args Array of arguments for WP_Comment_Query.
		 * @param WP_REST_Request $request       The REST API request.
		 */
		$prepared_args = apply_filters( &#039;rest_comment_query&#039;, $prepared_args, $request );

		$query        = new WP_Comment_Query();
		$query_result = $query-&gt;query( $prepared_args );

		if ( ! $is_head_request ) {
			$comments = array();

			foreach ( $query_result as $comment ) {
				if ( ! $this-&gt;check_read_permission( $comment, $request ) ) {
					continue;
				}

				$data       = $this-&gt;prepare_item_for_response( $comment, $request );
				$comments[] = $this-&gt;prepare_response_for_collection( $data );
			}
		}

		$total_comments = (int) $query-&gt;found_comments;
		$max_pages      = (int) $query-&gt;max_num_pages;

		if ( $total_comments &lt; 1 ) {
			// Out-of-bounds, run the query again without LIMIT for total count.
			unset( $prepared_args[&#039;number&#039;], $prepared_args[&#039;offset&#039;] );

			$query                    = new WP_Comment_Query();
			$prepared_args[&#039;count&#039;]   = true;
			$prepared_args[&#039;orderby&#039;] = &#039;none&#039;;

			$total_comments = $query-&gt;query( $prepared_args );
			$max_pages      = (int) ceil( $total_comments / $request[&#039;per_page&#039;] );
		}

		$response = $is_head_request ? new WP_REST_Response( array() ) : rest_ensure_response( $comments );
		$response-&gt;header( &#039;X-WP-Total&#039;, $total_comments );
		$response-&gt;header( &#039;X-WP-TotalPages&#039;, $max_pages );

		$base = add_query_arg( urlencode_deep( $request-&gt;get_query_params() ), rest_url( sprintf( &#039;%s/%s&#039;, $this-&gt;namespace, $this-&gt;rest_base ) ) );

		if ( $request[&#039;page&#039;] &gt; 1 ) {
			$prev_page = $request[&#039;page&#039;] - 1;

			if ( $prev_page &gt; $max_pages ) {
				$prev_page = $max_pages;
			}

			$prev_link = add_query_arg( &#039;page&#039;, $prev_page, $base );
			$response-&gt;link_header( &#039;prev&#039;, $prev_link );
		}

		if ( $max_pages &gt; $request[&#039;page&#039;] ) {
			$next_page = $request[&#039;page&#039;] + 1;
			$next_link = add_query_arg( &#039;page&#039;, $next_page, $base );

			$response-&gt;link_header( &#039;next&#039;, $next_link );
		}

		return $response;
	}

	/**
	 * Get the comment, if the ID is valid.
	 *
	 * @since 4.7.2
	 *
	 * @param int $id Supplied ID.
	 * @return WP_Comment|WP_Error Comment object if ID is valid, WP_Error otherwise.
	 */
	protected function get_comment( $id ) {
		$error = new WP_Error(
			&#039;rest_comment_invalid_id&#039;,
			__( &#039;Invalid comment ID.&#039; ),
			array( &#039;status&#039; =&gt; 404 )
		);

		if ( (int) $id &lt;= 0 ) {
			return $error;
		}

		$id      = (int) $id;
		$comment = get_comment( $id );
		if ( empty( $comment ) ) {
			return $error;
		}

		if ( ! empty( $comment-&gt;comment_post_ID ) ) {
			$post = get_post( (int) $comment-&gt;comment_post_ID );

			if ( empty( $post ) ) {
				return new WP_Error(
					&#039;rest_post_invalid_id&#039;,
					__( &#039;Invalid post ID.&#039; ),
					array( &#039;status&#039; =&gt; 404 )
				);
			}
		}

		return $comment;
	}

	/**
	 * Checks if a given request has access to read the comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error True if the request has read access for the item, error object otherwise.
	 */
	public function get_item_permissions_check( $request ) {
		$comment = $this-&gt;get_comment( $request[&#039;id&#039;] );
		if ( is_wp_error( $comment ) ) {
			return $comment;
		}

		if ( ! empty( $request[&#039;context&#039;] ) &amp;&amp; &#039;edit&#039; === $request[&#039;context&#039;] &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
			return new WP_Error(
				&#039;rest_forbidden_context&#039;,
				__( &#039;Sorry, you are not allowed to edit comments.&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		$post = get_post( $comment-&gt;comment_post_ID );

		if ( ! $this-&gt;check_read_permission( $comment, $request ) ) {
			return new WP_Error(
				&#039;rest_cannot_read&#039;,
				__( &#039;Sorry, you are not allowed to read this comment.&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		if ( $post &amp;&amp; ! $this-&gt;check_read_post_permission( $post, $request ) ) {
			return new WP_Error(
				&#039;rest_cannot_read_post&#039;,
				__( &#039;Sorry, you are not allowed to read the post for this comment.&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		return true;
	}

	/**
	 * Retrieves a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, or error object on failure.
	 */
	public function get_item( $request ) {
		$comment = $this-&gt;get_comment( $request[&#039;id&#039;] );
		if ( is_wp_error( $comment ) ) {
			return $comment;
		}

		$data     = $this-&gt;prepare_item_for_response( $comment, $request );
		$response = rest_ensure_response( $data );

		return $response;
	}

	/**
	 * Checks if a given request has access to create a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error True if the request has access to create items, error object otherwise.
	 */
	public function create_item_permissions_check( $request ) {
		if ( ! is_user_logged_in() ) {
			if ( get_option( &#039;comment_registration&#039; ) ) {
				return new WP_Error(
					&#039;rest_comment_login_required&#039;,
					__( &#039;Sorry, you must be logged in to comment.&#039; ),
					array( &#039;status&#039; =&gt; 401 )
				);
			}

			/**
			 * Filters whether comments can be created via the REST API without authentication.
			 *
			 * Enables creating comments for anonymous users.
			 *
			 * @since 4.7.0
			 *
			 * @param bool $allow_anonymous Whether to allow anonymous comments to
			 *                              be created. Default `false`.
			 * @param WP_REST_Request $request Request used to generate the
			 *                                 response.
			 */
			$allow_anonymous = apply_filters( &#039;rest_allow_anonymous_comments&#039;, false, $request );

			if ( ! $allow_anonymous ) {
				return new WP_Error(
					&#039;rest_comment_login_required&#039;,
					__( &#039;Sorry, you must be logged in to comment.&#039; ),
					array( &#039;status&#039; =&gt; 401 )
				);
			}
		}

		// Limit who can set comment `author`, `author_ip` or `status` to anything other than the default.
		if ( isset( $request[&#039;author&#039;] ) &amp;&amp; get_current_user_id() !== $request[&#039;author&#039;] &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
			return new WP_Error(
				&#039;rest_comment_invalid_author&#039;,
				/* translators: %s: Request parameter. */
				sprintf( __( &quot;Sorry, you are not allowed to edit &#039;%s&#039; for comments.&quot; ), &#039;author&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		if ( isset( $request[&#039;author_ip&#039;] ) &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
			if ( empty( $_SERVER[&#039;REMOTE_ADDR&#039;] ) || $request[&#039;author_ip&#039;] !== $_SERVER[&#039;REMOTE_ADDR&#039;] ) {
				return new WP_Error(
					&#039;rest_comment_invalid_author_ip&#039;,
					/* translators: %s: Request parameter. */
					sprintf( __( &quot;Sorry, you are not allowed to edit &#039;%s&#039; for comments.&quot; ), &#039;author_ip&#039; ),
					array( &#039;status&#039; =&gt; rest_authorization_required_code() )
				);
			}
		}

		if ( isset( $request[&#039;status&#039;] ) &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
			return new WP_Error(
				&#039;rest_comment_invalid_status&#039;,
				/* translators: %s: Request parameter. */
				sprintf( __( &quot;Sorry, you are not allowed to edit &#039;%s&#039; for comments.&quot; ), &#039;status&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		if ( empty( $request[&#039;post&#039;] ) ) {
			return new WP_Error(
				&#039;rest_comment_invalid_post_id&#039;,
				__( &#039;Sorry, you are not allowed to create this comment without a post.&#039; ),
				array( &#039;status&#039; =&gt; 403 )
			);
		}

		$post = get_post( (int) $request[&#039;post&#039;] );

		if ( ! $post ) {
			return new WP_Error(
				&#039;rest_comment_invalid_post_id&#039;,
				__( &#039;Sorry, you are not allowed to create this comment without a post.&#039; ),
				array( &#039;status&#039; =&gt; 403 )
			);
		}

		if ( &#039;draft&#039; === $post-&gt;post_status ) {
			return new WP_Error(
				&#039;rest_comment_draft_post&#039;,
				__( &#039;Sorry, you are not allowed to create a comment on this post.&#039; ),
				array( &#039;status&#039; =&gt; 403 )
			);
		}

		if ( &#039;trash&#039; === $post-&gt;post_status ) {
			return new WP_Error(
				&#039;rest_comment_trash_post&#039;,
				__( &#039;Sorry, you are not allowed to create a comment on this post.&#039; ),
				array( &#039;status&#039; =&gt; 403 )
			);
		}

		if ( ! $this-&gt;check_read_post_permission( $post, $request ) ) {
			return new WP_Error(
				&#039;rest_cannot_read_post&#039;,
				__( &#039;Sorry, you are not allowed to read the post for this comment.&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		if ( ! comments_open( $post-&gt;ID ) ) {
			return new WP_Error(
				&#039;rest_comment_closed&#039;,
				__( &#039;Sorry, comments are closed for this item.&#039; ),
				array( &#039;status&#039; =&gt; 403 )
			);
		}

		return true;
	}

	/**
	 * Creates a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, or error object on failure.
	 */
	public function create_item( $request ) {
		if ( ! empty( $request[&#039;id&#039;] ) ) {
			return new WP_Error(
				&#039;rest_comment_exists&#039;,
				__( &#039;Cannot create existing comment.&#039; ),
				array( &#039;status&#039; =&gt; 400 )
			);
		}

		// Do not allow comments to be created with a non-default type.
		if ( ! empty( $request[&#039;type&#039;] ) &amp;&amp; &#039;comment&#039; !== $request[&#039;type&#039;] ) {
			return new WP_Error(
				&#039;rest_invalid_comment_type&#039;,
				__( &#039;Cannot create a comment with that type.&#039; ),
				array( &#039;status&#039; =&gt; 400 )
			);
		}

		$prepared_comment = $this-&gt;prepare_item_for_database( $request );
		if ( is_wp_error( $prepared_comment ) ) {
			return $prepared_comment;
		}

		$prepared_comment[&#039;comment_type&#039;] = &#039;comment&#039;;

		if ( ! isset( $prepared_comment[&#039;comment_content&#039;] ) ) {
			$prepared_comment[&#039;comment_content&#039;] = &#039;&#039;;
		}

		if ( ! $this-&gt;check_is_comment_content_allowed( $prepared_comment ) ) {
			return new WP_Error(
				&#039;rest_comment_content_invalid&#039;,
				__( &#039;Invalid comment content.&#039; ),
				array( &#039;status&#039; =&gt; 400 )
			);
		}

		// Setting remaining values before wp_insert_comment so we can use wp_allow_comment().
		if ( ! isset( $prepared_comment[&#039;comment_date_gmt&#039;] ) ) {
			$prepared_comment[&#039;comment_date_gmt&#039;] = current_time( &#039;mysql&#039;, true );
		}

		// Set author data if the user&#039;s logged in.
		$missing_author = empty( $prepared_comment[&#039;user_id&#039;] )
			&amp;&amp; empty( $prepared_comment[&#039;comment_author&#039;] )
			&amp;&amp; empty( $prepared_comment[&#039;comment_author_email&#039;] )
			&amp;&amp; empty( $prepared_comment[&#039;comment_author_url&#039;] );

		if ( is_user_logged_in() &amp;&amp; $missing_author ) {
			$user = wp_get_current_user();

			$prepared_comment[&#039;user_id&#039;]              = $user-&gt;ID;
			$prepared_comment[&#039;comment_author&#039;]       = $user-&gt;display_name;
			$prepared_comment[&#039;comment_author_email&#039;] = $user-&gt;user_email;
			$prepared_comment[&#039;comment_author_url&#039;]   = $user-&gt;user_url;
		}

		// Honor the discussion setting that requires a name and email address of the comment author.
		if ( get_option( &#039;require_name_email&#039; ) ) {
			if ( empty( $prepared_comment[&#039;comment_author&#039;] ) || empty( $prepared_comment[&#039;comment_author_email&#039;] ) ) {
				return new WP_Error(
					&#039;rest_comment_author_data_required&#039;,
					__( &#039;Creating a comment requires valid author name and email values.&#039; ),
					array( &#039;status&#039; =&gt; 400 )
				);
			}
		}

		if ( ! isset( $prepared_comment[&#039;comment_author_email&#039;] ) ) {
			$prepared_comment[&#039;comment_author_email&#039;] = &#039;&#039;;
		}

		if ( ! isset( $prepared_comment[&#039;comment_author_url&#039;] ) ) {
			$prepared_comment[&#039;comment_author_url&#039;] = &#039;&#039;;
		}

		if ( ! isset( $prepared_comment[&#039;comment_agent&#039;] ) ) {
			$prepared_comment[&#039;comment_agent&#039;] = &#039;&#039;;
		}

		$check_comment_lengths = wp_check_comment_data_max_lengths( $prepared_comment );

		if ( is_wp_error( $check_comment_lengths ) ) {
			$error_code = $check_comment_lengths-&gt;get_error_code();
			return new WP_Error(
				$error_code,
				__( &#039;Comment field exceeds maximum length allowed.&#039; ),
				array( &#039;status&#039; =&gt; 400 )
			);
		}

		$prepared_comment[&#039;comment_approved&#039;] = wp_allow_comment( $prepared_comment, true );

		if ( is_wp_error( $prepared_comment[&#039;comment_approved&#039;] ) ) {
			$error_code    = $prepared_comment[&#039;comment_approved&#039;]-&gt;get_error_code();
			$error_message = $prepared_comment[&#039;comment_approved&#039;]-&gt;get_error_message();

			if ( &#039;comment_duplicate&#039; === $error_code ) {
				return new WP_Error(
					$error_code,
					$error_message,
					array( &#039;status&#039; =&gt; 409 )
				);
			}

			if ( &#039;comment_flood&#039; === $error_code ) {
				return new WP_Error(
					$error_code,
					$error_message,
					array( &#039;status&#039; =&gt; 400 )
				);
			}

			return $prepared_comment[&#039;comment_approved&#039;];
		}

		/**
		 * Filters a comment before it is inserted via the REST API.
		 *
		 * Allows modification of the comment right before it is inserted via wp_insert_comment().
		 * Returning a WP_Error value from the filter will short-circuit insertion and allow
		 * skipping further processing.
		 *
		 * @since 4.7.0
		 * @since 4.8.0 `$prepared_comment` can now be a WP_Error to short-circuit insertion.
		 *
		 * @param array|WP_Error  $prepared_comment The prepared comment data for wp_insert_comment().
		 * @param WP_REST_Request $request          Request used to insert the comment.
		 */
		$prepared_comment = apply_filters( &#039;rest_pre_insert_comment&#039;, $prepared_comment, $request );
		if ( is_wp_error( $prepared_comment ) ) {
			return $prepared_comment;
		}

		$comment_id = wp_insert_comment( wp_filter_comment( wp_slash( (array) $prepared_comment ) ) );

		if ( ! $comment_id ) {
			return new WP_Error(
				&#039;rest_comment_failed_create&#039;,
				__( &#039;Creating comment failed.&#039; ),
				array( &#039;status&#039; =&gt; 500 )
			);
		}

		if ( isset( $request[&#039;status&#039;] ) ) {
			$this-&gt;handle_status_param( $request[&#039;status&#039;], $comment_id );
		}

		$comment = get_comment( $comment_id );

		/**
		 * Fires after a comment is created or updated via the REST API.
		 *
		 * @since 4.7.0
		 *
		 * @param WP_Comment      $comment  Inserted or updated comment object.
		 * @param WP_REST_Request $request  Request object.
		 * @param bool            $creating True when creating a comment, false
		 *                                  when updating.
		 */
		do_action( &#039;rest_insert_comment&#039;, $comment, $request, true );

		$schema = $this-&gt;get_item_schema();

		if ( ! empty( $schema[&#039;properties&#039;][&#039;meta&#039;] ) &amp;&amp; isset( $request[&#039;meta&#039;] ) ) {
			$meta_update = $this-&gt;meta-&gt;update_value( $request[&#039;meta&#039;], $comment_id );

			if ( is_wp_error( $meta_update ) ) {
				return $meta_update;
			}
		}

		$fields_update = $this-&gt;update_additional_fields_for_object( $comment, $request );

		if ( is_wp_error( $fields_update ) ) {
			return $fields_update;
		}

		$context = current_user_can( &#039;moderate_comments&#039; ) ? &#039;edit&#039; : &#039;view&#039;;
		$request-&gt;set_param( &#039;context&#039;, $context );

		/**
		 * Fires completely after a comment is created or updated via the REST API.
		 *
		 * @since 5.0.0
		 *
		 * @param WP_Comment      $comment  Inserted or updated comment object.
		 * @param WP_REST_Request $request  Request object.
		 * @param bool            $creating True when creating a comment, false
		 *                                  when updating.
		 */
		do_action( &#039;rest_after_insert_comment&#039;, $comment, $request, true );

		$response = $this-&gt;prepare_item_for_response( $comment, $request );
		$response = rest_ensure_response( $response );

		$response-&gt;set_status( 201 );
		$response-&gt;header( &#039;Location&#039;, rest_url( sprintf( &#039;%s/%s/%d&#039;, $this-&gt;namespace, $this-&gt;rest_base, $comment_id ) ) );

		return $response;
	}

	/**
	 * Checks if a given REST request has access to update a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error True if the request has access to update the item, error object otherwise.
	 */
	public function update_item_permissions_check( $request ) {
		$comment = $this-&gt;get_comment( $request[&#039;id&#039;] );
		if ( is_wp_error( $comment ) ) {
			return $comment;
		}

		if ( ! $this-&gt;check_edit_permission( $comment ) ) {
			return new WP_Error(
				&#039;rest_cannot_edit&#039;,
				__( &#039;Sorry, you are not allowed to edit this comment.&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}

		return true;
	}

	/**
	 * Updates a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, or error object on failure.
	 */
	public function update_item( $request ) {
		$comment = $this-&gt;get_comment( $request[&#039;id&#039;] );
		if ( is_wp_error( $comment ) ) {
			return $comment;
		}

		$id = $comment-&gt;comment_ID;

		if ( isset( $request[&#039;type&#039;] ) &amp;&amp; get_comment_type( $id ) !== $request[&#039;type&#039;] ) {
			return new WP_Error(
				&#039;rest_comment_invalid_type&#039;,
				__( &#039;Sorry, you are not allowed to change the comment type.&#039; ),
				array( &#039;status&#039; =&gt; 404 )
			);
		}

		$prepared_args = $this-&gt;prepare_item_for_database( $request );

		if ( is_wp_error( $prepared_args ) ) {
			return $prepared_args;
		}

		if ( ! empty( $prepared_args[&#039;comment_post_ID&#039;] ) ) {
			$post = get_post( $prepared_args[&#039;comment_post_ID&#039;] );

			if ( empty( $post ) ) {
				return new WP_Error(
					&#039;rest_comment_invalid_post_id&#039;,
					__( &#039;Invalid post ID.&#039; ),
					array( &#039;status&#039; =&gt; 403 )
				);
			}
		}

		if ( empty( $prepared_args ) &amp;&amp; isset( $request[&#039;status&#039;] ) ) {
			// Only the comment status is being changed.
			$change = $this-&gt;handle_status_param( $request[&#039;status&#039;], $id );

			if ( ! $change ) {
				return new WP_Error(
					&#039;rest_comment_failed_edit&#039;,
					__( &#039;Updating comment status failed.&#039; ),
					array( &#039;status&#039; =&gt; 500 )
				);
			}
		} elseif ( ! empty( $prepared_args ) ) {
			if ( is_wp_error( $prepared_args ) ) {
				return $prepared_args;
			}

			if ( isset( $prepared_args[&#039;comment_content&#039;] ) &amp;&amp; empty( $prepared_args[&#039;comment_content&#039;] ) ) {
				return new WP_Error(
					&#039;rest_comment_content_invalid&#039;,
					__( &#039;Invalid comment content.&#039; ),
					array( &#039;status&#039; =&gt; 400 )
				);
			}

			$prepared_args[&#039;comment_ID&#039;] = $id;

			$check_comment_lengths = wp_check_comment_data_max_lengths( $prepared_args );

			if ( is_wp_error( $check_comment_lengths ) ) {
				$error_code = $check_comment_lengths-&gt;get_error_code();
				return new WP_Error(
					$error_code,
					__( &#039;Comment field exceeds maximum length allowed.&#039; ),
					array( &#039;status&#039; =&gt; 400 )
				);
			}

			$updated = wp_update_comment( wp_slash( (array) $prepared_args ), true );

			if ( is_wp_error( $updated ) ) {
				return new WP_Error(
					&#039;rest_comment_failed_edit&#039;,
					__( &#039;Updating comment failed.&#039; ),
					array( &#039;status&#039; =&gt; 500 )
				);
			}

			if ( isset( $request[&#039;status&#039;] ) ) {
				$this-&gt;handle_status_param( $request[&#039;status&#039;], $id );
			}
		}

		$comment = get_comment( $id );

		/** This action is documented in wp-includes/rest-api/endpoints/class-wp-rest-comments-controller.php */
		do_action( &#039;rest_insert_comment&#039;, $comment, $request, false );

		$schema = $this-&gt;get_item_schema();

		if ( ! empty( $schema[&#039;properties&#039;][&#039;meta&#039;] ) &amp;&amp; isset( $request[&#039;meta&#039;] ) ) {
			$meta_update = $this-&gt;meta-&gt;update_value( $request[&#039;meta&#039;], $id );

			if ( is_wp_error( $meta_update ) ) {
				return $meta_update;
			}
		}

		$fields_update = $this-&gt;update_additional_fields_for_object( $comment, $request );

		if ( is_wp_error( $fields_update ) ) {
			return $fields_update;
		}

		$request-&gt;set_param( &#039;context&#039;, &#039;edit&#039; );

		/** This action is documented in wp-includes/rest-api/endpoints/class-wp-rest-comments-controller.php */
		do_action( &#039;rest_after_insert_comment&#039;, $comment, $request, false );

		$response = $this-&gt;prepare_item_for_response( $comment, $request );

		return rest_ensure_response( $response );
	}

	/**
	 * Checks if a given request has access to delete a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error True if the request has access to delete the item, error object otherwise.
	 */
	public function delete_item_permissions_check( $request ) {
		$comment = $this-&gt;get_comment( $request[&#039;id&#039;] );
		if ( is_wp_error( $comment ) ) {
			return $comment;
		}

		if ( ! $this-&gt;check_edit_permission( $comment ) ) {
			return new WP_Error(
				&#039;rest_cannot_delete&#039;,
				__( &#039;Sorry, you are not allowed to delete this comment.&#039; ),
				array( &#039;status&#039; =&gt; rest_authorization_required_code() )
			);
		}
		return true;
	}

	/**
	 * Deletes a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, or error object on failure.
	 */
	public function delete_item( $request ) {
		$comment = $this-&gt;get_comment( $request[&#039;id&#039;] );
		if ( is_wp_error( $comment ) ) {
			return $comment;
		}

		$force = isset( $request[&#039;force&#039;] ) ? (bool) $request[&#039;force&#039;] : false;

		/**
		 * Filters whether a comment can be trashed via the REST API.
		 *
		 * Return false to disable trash support for the comment.
		 *
		 * @since 4.7.0
		 *
		 * @param bool       $supports_trash Whether the comment supports trashing.
		 * @param WP_Comment $comment        The comment object being considered for trashing support.
		 */
		$supports_trash = apply_filters( &#039;rest_comment_trashable&#039;, ( EMPTY_TRASH_DAYS &gt; 0 ), $comment );

		$request-&gt;set_param( &#039;context&#039;, &#039;edit&#039; );

		if ( $force ) {
			$previous = $this-&gt;prepare_item_for_response( $comment, $request );
			$result   = wp_delete_comment( $comment-&gt;comment_ID, true );
			$response = new WP_REST_Response();
			$response-&gt;set_data(
				array(
					&#039;deleted&#039;  =&gt; true,
					&#039;previous&#039; =&gt; $previous-&gt;get_data(),
				)
			);
		} else {
			// If this type doesn&#039;t support trashing, error out.
			if ( ! $supports_trash ) {
				return new WP_Error(
					&#039;rest_trash_not_supported&#039;,
					/* translators: %s: force=true */
					sprintf( __( &quot;The comment does not support trashing. Set &#039;%s&#039; to delete.&quot; ), &#039;force=true&#039; ),
					array( &#039;status&#039; =&gt; 501 )
				);
			}

			if ( &#039;trash&#039; === $comment-&gt;comment_approved ) {
				return new WP_Error(
					&#039;rest_already_trashed&#039;,
					__( &#039;The comment has already been trashed.&#039; ),
					array( &#039;status&#039; =&gt; 410 )
				);
			}

			$result   = wp_trash_comment( $comment-&gt;comment_ID );
			$comment  = get_comment( $comment-&gt;comment_ID );
			$response = $this-&gt;prepare_item_for_response( $comment, $request );
		}

		if ( ! $result ) {
			return new WP_Error(
				&#039;rest_cannot_delete&#039;,
				__( &#039;The comment cannot be deleted.&#039; ),
				array( &#039;status&#039; =&gt; 500 )
			);
		}

		/**
		 * Fires after a comment is deleted via the REST API.
		 *
		 * @since 4.7.0
		 *
		 * @param WP_Comment       $comment  The deleted comment data.
		 * @param WP_REST_Response $response The response returned from the API.
		 * @param WP_REST_Request  $request  The request sent to the API.
		 */
		do_action( &#039;rest_delete_comment&#039;, $comment, $response, $request );

		return $response;
	}

	/**
	 * Prepares a single comment output for response.
	 *
	 * @since 4.7.0
	 * @since 5.9.0 Renamed `$comment` to `$item` to match parent class for PHP 8 named parameter support.
	 *
	 * @param WP_Comment      $item    Comment object.
	 * @param WP_REST_Request $request Request object.
	 * @return WP_REST_Response Response object.
	 */
	public function prepare_item_for_response( $item, $request ) {
		// Restores the more descriptive, specific name for use within this method.
		$comment = $item;

		// Don&#039;t prepare the response body for HEAD requests.
		if ( $request-&gt;is_method( &#039;HEAD&#039; ) ) {
			/** This filter is documented in wp-includes/rest-api/endpoints/class-wp-rest-comments-controller.php */
			return apply_filters( &#039;rest_prepare_comment&#039;, new WP_REST_Response( array() ), $comment, $request );
		}

		$fields = $this-&gt;get_fields_for_response( $request );
		$data   = array();

		if ( in_array( &#039;id&#039;, $fields, true ) ) {
			$data[&#039;id&#039;] = (int) $comment-&gt;comment_ID;
		}

		if ( in_array( &#039;post&#039;, $fields, true ) ) {
			$data[&#039;post&#039;] = (int) $comment-&gt;comment_post_ID;
		}

		if ( in_array( &#039;parent&#039;, $fields, true ) ) {
			$data[&#039;parent&#039;] = (int) $comment-&gt;comment_parent;
		}

		if ( in_array( &#039;author&#039;, $fields, true ) ) {
			$data[&#039;author&#039;] = (int) $comment-&gt;user_id;
		}

		if ( in_array( &#039;author_name&#039;, $fields, true ) ) {
			$data[&#039;author_name&#039;] = $comment-&gt;comment_author;
		}

		if ( in_array( &#039;author_email&#039;, $fields, true ) ) {
			$data[&#039;author_email&#039;] = $comment-&gt;comment_author_email;
		}

		if ( in_array( &#039;author_url&#039;, $fields, true ) ) {
			$data[&#039;author_url&#039;] = $comment-&gt;comment_author_url;
		}

		if ( in_array( &#039;author_ip&#039;, $fields, true ) ) {
			$data[&#039;author_ip&#039;] = $comment-&gt;comment_author_IP;
		}

		if ( in_array( &#039;author_user_agent&#039;, $fields, true ) ) {
			$data[&#039;author_user_agent&#039;] = $comment-&gt;comment_agent;
		}

		if ( in_array( &#039;date&#039;, $fields, true ) ) {
			$data[&#039;date&#039;] = mysql_to_rfc3339( $comment-&gt;comment_date );
		}

		if ( in_array( &#039;date_gmt&#039;, $fields, true ) ) {
			$data[&#039;date_gmt&#039;] = mysql_to_rfc3339( $comment-&gt;comment_date_gmt );
		}

		if ( in_array( &#039;content&#039;, $fields, true ) ) {
			$data[&#039;content&#039;] = array(
				/** This filter is documented in wp-includes/comment-template.php */
				&#039;rendered&#039; =&gt; apply_filters( &#039;comment_text&#039;, $comment-&gt;comment_content, $comment, array() ),
				&#039;raw&#039;      =&gt; $comment-&gt;comment_content,
			);
		}

		if ( in_array( &#039;link&#039;, $fields, true ) ) {
			$data[&#039;link&#039;] = get_comment_link( $comment );
		}

		if ( in_array( &#039;status&#039;, $fields, true ) ) {
			$data[&#039;status&#039;] = $this-&gt;prepare_status_response( $comment-&gt;comment_approved );
		}

		if ( in_array( &#039;type&#039;, $fields, true ) ) {
			$data[&#039;type&#039;] = get_comment_type( $comment-&gt;comment_ID );
		}

		if ( in_array( &#039;author_avatar_urls&#039;, $fields, true ) ) {
			$data[&#039;author_avatar_urls&#039;] = rest_get_avatar_urls( $comment );
		}

		if ( in_array( &#039;meta&#039;, $fields, true ) ) {
			$data[&#039;meta&#039;] = $this-&gt;meta-&gt;get_value( $comment-&gt;comment_ID, $request );
		}

		$context = ! empty( $request[&#039;context&#039;] ) ? $request[&#039;context&#039;] : &#039;view&#039;;
		$data    = $this-&gt;add_additional_fields_to_object( $data, $request );
		$data    = $this-&gt;filter_response_by_context( $data, $context );

		// Wrap the data in a response object.
		$response = rest_ensure_response( $data );

		if ( rest_is_field_included( &#039;_links&#039;, $fields ) || rest_is_field_included( &#039;_embedded&#039;, $fields ) ) {
			$response-&gt;add_links( $this-&gt;prepare_links( $comment ) );
		}

		/**
		 * Filters a comment returned from the REST API.
		 *
		 * Allows modification of the comment right before it is returned.
		 *
		 * @since 4.7.0
		 *
		 * @param WP_REST_Response  $response The response object.
		 * @param WP_Comment        $comment  The original comment object.
		 * @param WP_REST_Request   $request  Request used to generate the response.
		 */
		return apply_filters( &#039;rest_prepare_comment&#039;, $response, $comment, $request );
	}

	/**
	 * Prepares links for the request.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_Comment $comment Comment object.
	 * @return array Links for the given comment.
	 */
	protected function prepare_links( $comment ) {
		$links = array(
			&#039;self&#039;       =&gt; array(
				&#039;href&#039; =&gt; rest_url( sprintf( &#039;%s/%s/%d&#039;, $this-&gt;namespace, $this-&gt;rest_base, $comment-&gt;comment_ID ) ),
			),
			&#039;collection&#039; =&gt; array(
				&#039;href&#039; =&gt; rest_url( sprintf( &#039;%s/%s&#039;, $this-&gt;namespace, $this-&gt;rest_base ) ),
			),
		);

		if ( 0 !== (int) $comment-&gt;user_id ) {
			$links[&#039;author&#039;] = array(
				&#039;href&#039;       =&gt; rest_url( &#039;wp/v2/users/&#039; . $comment-&gt;user_id ),
				&#039;embeddable&#039; =&gt; true,
			);
		}

		if ( 0 !== (int) $comment-&gt;comment_post_ID ) {
			$post       = get_post( $comment-&gt;comment_post_ID );
			$post_route = rest_get_route_for_post( $post );

			if ( ! empty( $post-&gt;ID ) &amp;&amp; $post_route ) {
				$links[&#039;up&#039;] = array(
					&#039;href&#039;       =&gt; rest_url( $post_route ),
					&#039;embeddable&#039; =&gt; true,
					&#039;post_type&#039;  =&gt; $post-&gt;post_type,
				);
			}
		}

		if ( 0 !== (int) $comment-&gt;comment_parent ) {
			$links[&#039;in-reply-to&#039;] = array(
				&#039;href&#039;       =&gt; rest_url( sprintf( &#039;%s/%s/%d&#039;, $this-&gt;namespace, $this-&gt;rest_base, $comment-&gt;comment_parent ) ),
				&#039;embeddable&#039; =&gt; true,
			);
		}

		// Only grab one comment to verify the comment has children.
		$comment_children = $comment-&gt;get_children(
			array(
				&#039;count&#039;   =&gt; true,
				&#039;orderby&#039; =&gt; &#039;none&#039;,
			)
		);

		if ( ! empty( $comment_children ) ) {
			$args = array(
				&#039;parent&#039; =&gt; $comment-&gt;comment_ID,
			);

			$rest_url = add_query_arg( $args, rest_url( $this-&gt;namespace . &#039;/&#039; . $this-&gt;rest_base ) );

			$links[&#039;children&#039;] = array(
				&#039;href&#039;       =&gt; $rest_url,
				&#039;embeddable&#039; =&gt; true,
			);
		}

		return $links;
	}

	/**
	 * Prepends internal property prefix to query parameters to match our response fields.
	 *
	 * @since 4.7.0
	 *
	 * @param string $query_param Query parameter.
	 * @return string The normalized query parameter.
	 */
	protected function normalize_query_param( $query_param ) {
		$prefix = &#039;comment_&#039;;

		switch ( $query_param ) {
			case &#039;id&#039;:
				$normalized = $prefix . &#039;ID&#039;;
				break;
			case &#039;post&#039;:
				$normalized = $prefix . &#039;post_ID&#039;;
				break;
			case &#039;parent&#039;:
				$normalized = $prefix . &#039;parent&#039;;
				break;
			case &#039;include&#039;:
				$normalized = &#039;comment__in&#039;;
				break;
			default:
				$normalized = $prefix . $query_param;
				break;
		}

		return $normalized;
	}

	/**
	 * Checks comment_approved to set comment status for single comment output.
	 *
	 * @since 4.7.0
	 *
	 * @param string $comment_approved Comment status.
	 * @return string Comment status.
	 */
	protected function prepare_status_response( $comment_approved ) {

		switch ( $comment_approved ) {
			case &#039;hold&#039;:
			case &#039;0&#039;:
				$status = &#039;hold&#039;;
				break;

			case &#039;approve&#039;:
			case &#039;1&#039;:
				$status = &#039;approved&#039;;
				break;

			case &#039;spam&#039;:
			case &#039;trash&#039;:
			default:
				$status = $comment_approved;
				break;
		}

		return $status;
	}

	/**
	 * Prepares a single comment to be inserted into the database.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Request object.
	 * @return array|WP_Error Prepared comment, otherwise WP_Error object.
	 */
	protected function prepare_item_for_database( $request ) {
		$prepared_comment = array();

		/*
		 * Allow the comment_content to be set via the &#039;content&#039; or
		 * the &#039;content.raw&#039; properties of the Request object.
		 */
		if ( isset( $request[&#039;content&#039;] ) &amp;&amp; is_string( $request[&#039;content&#039;] ) ) {
			$prepared_comment[&#039;comment_content&#039;] = trim( $request[&#039;content&#039;] );
		} elseif ( isset( $request[&#039;content&#039;][&#039;raw&#039;] ) &amp;&amp; is_string( $request[&#039;content&#039;][&#039;raw&#039;] ) ) {
			$prepared_comment[&#039;comment_content&#039;] = trim( $request[&#039;content&#039;][&#039;raw&#039;] );
		}

		if ( isset( $request[&#039;post&#039;] ) ) {
			$prepared_comment[&#039;comment_post_ID&#039;] = (int) $request[&#039;post&#039;];
		}

		if ( isset( $request[&#039;parent&#039;] ) ) {
			$prepared_comment[&#039;comment_parent&#039;] = $request[&#039;parent&#039;];
		}

		if ( isset( $request[&#039;author&#039;] ) ) {
			$user = new WP_User( $request[&#039;author&#039;] );

			if ( $user-&gt;exists() ) {
				$prepared_comment[&#039;user_id&#039;]              = $user-&gt;ID;
				$prepared_comment[&#039;comment_author&#039;]       = $user-&gt;display_name;
				$prepared_comment[&#039;comment_author_email&#039;] = $user-&gt;user_email;
				$prepared_comment[&#039;comment_author_url&#039;]   = $user-&gt;user_url;
			} else {
				return new WP_Error(
					&#039;rest_comment_author_invalid&#039;,
					__( &#039;Invalid comment author ID.&#039; ),
					array( &#039;status&#039; =&gt; 400 )
				);
			}
		}

		if ( isset( $request[&#039;author_name&#039;] ) ) {
			$prepared_comment[&#039;comment_author&#039;] = $request[&#039;author_name&#039;];
		}

		if ( isset( $request[&#039;author_email&#039;] ) ) {
			$prepared_comment[&#039;comment_author_email&#039;] = $request[&#039;author_email&#039;];
		}

		if ( isset( $request[&#039;author_url&#039;] ) ) {
			$prepared_comment[&#039;comment_author_url&#039;] = $request[&#039;author_url&#039;];
		}

		if ( isset( $request[&#039;author_ip&#039;] ) &amp;&amp; current_user_can( &#039;moderate_comments&#039; ) ) {
			$prepared_comment[&#039;comment_author_IP&#039;] = $request[&#039;author_ip&#039;];
		} elseif ( ! empty( $_SERVER[&#039;REMOTE_ADDR&#039;] ) &amp;&amp; rest_is_ip_address( $_SERVER[&#039;REMOTE_ADDR&#039;] ) ) {
			$prepared_comment[&#039;comment_author_IP&#039;] = $_SERVER[&#039;REMOTE_ADDR&#039;];
		} else {
			$prepared_comment[&#039;comment_author_IP&#039;] = &#039;127.0.0.1&#039;;
		}

		if ( ! empty( $request[&#039;author_user_agent&#039;] ) ) {
			$prepared_comment[&#039;comment_agent&#039;] = $request[&#039;author_user_agent&#039;];
		} elseif ( $request-&gt;get_header( &#039;user_agent&#039; ) ) {
			$prepared_comment[&#039;comment_agent&#039;] = $request-&gt;get_header( &#039;user_agent&#039; );
		}

		if ( ! empty( $request[&#039;date&#039;] ) ) {
			$date_data = rest_get_date_with_gmt( $request[&#039;date&#039;] );

			if ( ! empty( $date_data ) ) {
				list( $prepared_comment[&#039;comment_date&#039;], $prepared_comment[&#039;comment_date_gmt&#039;] ) = $date_data;
			}
		} elseif ( ! empty( $request[&#039;date_gmt&#039;] ) ) {
			$date_data = rest_get_date_with_gmt( $request[&#039;date_gmt&#039;], true );

			if ( ! empty( $date_data ) ) {
				list( $prepared_comment[&#039;comment_date&#039;], $prepared_comment[&#039;comment_date_gmt&#039;] ) = $date_data;
			}
		}

		/**
		 * Filters a comment added via the REST API after it is prepared for insertion into the database.
		 *
		 * Allows modification of the comment right after it is prepared for the database.
		 *
		 * @since 4.7.0
		 *
		 * @param array           $prepared_comment The prepared comment data for `wp_insert_comment`.
		 * @param WP_REST_Request $request          The current request.
		 */
		return apply_filters( &#039;rest_preprocess_comment&#039;, $prepared_comment, $request );
	}

	/**
	 * Retrieves the comment&#039;s schema, conforming to JSON Schema.
	 *
	 * @since 4.7.0
	 *
	 * @return array
	 */
	public function get_item_schema() {
		if ( $this-&gt;schema ) {
			return $this-&gt;add_additional_fields_schema( $this-&gt;schema );
		}

		$schema = array(
			&#039;$schema&#039;    =&gt; &#039;http://json-schema.org/draft-04/schema#&#039;,
			&#039;title&#039;      =&gt; &#039;comment&#039;,
			&#039;type&#039;       =&gt; &#039;object&#039;,
			&#039;properties&#039; =&gt; array(
				&#039;id&#039;                =&gt; array(
					&#039;description&#039; =&gt; __( &#039;Unique identifier for the comment.&#039; ),
					&#039;type&#039;        =&gt; &#039;integer&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
					&#039;readonly&#039;    =&gt; true,
				),
				&#039;author&#039;            =&gt; array(
					&#039;description&#039; =&gt; __( &#039;The ID of the user object, if author was a user.&#039; ),
					&#039;type&#039;        =&gt; &#039;integer&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
				),
				&#039;author_email&#039;      =&gt; array(
					&#039;description&#039; =&gt; __( &#039;Email address for the comment author.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;format&#039;      =&gt; &#039;email&#039;,
					&#039;context&#039;     =&gt; array( &#039;edit&#039; ),
					&#039;arg_options&#039; =&gt; array(
						&#039;sanitize_callback&#039; =&gt; array( $this, &#039;check_comment_author_email&#039; ),
						&#039;validate_callback&#039; =&gt; null, // Skip built-in validation of &#039;email&#039;.
					),
				),
				&#039;author_ip&#039;         =&gt; array(
					&#039;description&#039; =&gt; __( &#039;IP address for the comment author.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;format&#039;      =&gt; &#039;ip&#039;,
					&#039;context&#039;     =&gt; array( &#039;edit&#039; ),
				),
				&#039;author_name&#039;       =&gt; array(
					&#039;description&#039; =&gt; __( &#039;Display name for the comment author.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
					&#039;arg_options&#039; =&gt; array(
						&#039;sanitize_callback&#039; =&gt; &#039;sanitize_text_field&#039;,
					),
				),
				&#039;author_url&#039;        =&gt; array(
					&#039;description&#039; =&gt; __( &#039;URL for the comment author.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;format&#039;      =&gt; &#039;uri&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
				),
				&#039;author_user_agent&#039; =&gt; array(
					&#039;description&#039; =&gt; __( &#039;User agent for the comment author.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;context&#039;     =&gt; array( &#039;edit&#039; ),
					&#039;arg_options&#039; =&gt; array(
						&#039;sanitize_callback&#039; =&gt; &#039;sanitize_text_field&#039;,
					),
				),
				&#039;content&#039;           =&gt; array(
					&#039;description&#039; =&gt; __( &#039;The content for the comment.&#039; ),
					&#039;type&#039;        =&gt; &#039;object&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
					&#039;arg_options&#039; =&gt; array(
						&#039;sanitize_callback&#039; =&gt; null, // Note: sanitization implemented in self::prepare_item_for_database().
						&#039;validate_callback&#039; =&gt; null, // Note: validation implemented in self::prepare_item_for_database().
					),
					&#039;properties&#039;  =&gt; array(
						&#039;raw&#039;      =&gt; array(
							&#039;description&#039; =&gt; __( &#039;Content for the comment, as it exists in the database.&#039; ),
							&#039;type&#039;        =&gt; &#039;string&#039;,
							&#039;context&#039;     =&gt; array( &#039;edit&#039; ),
						),
						&#039;rendered&#039; =&gt; array(
							&#039;description&#039; =&gt; __( &#039;HTML content for the comment, transformed for display.&#039; ),
							&#039;type&#039;        =&gt; &#039;string&#039;,
							&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
							&#039;readonly&#039;    =&gt; true,
						),
					),
				),
				&#039;date&#039;              =&gt; array(
					&#039;description&#039; =&gt; __( &quot;The date the comment was published, in the site&#039;s timezone.&quot; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;format&#039;      =&gt; &#039;date-time&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
				),
				&#039;date_gmt&#039;          =&gt; array(
					&#039;description&#039; =&gt; __( &#039;The date the comment was published, as GMT.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;format&#039;      =&gt; &#039;date-time&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039; ),
				),
				&#039;link&#039;              =&gt; array(
					&#039;description&#039; =&gt; __( &#039;URL to the comment.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;format&#039;      =&gt; &#039;uri&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
					&#039;readonly&#039;    =&gt; true,
				),
				&#039;parent&#039;            =&gt; array(
					&#039;description&#039; =&gt; __( &#039;The ID for the parent of the comment.&#039; ),
					&#039;type&#039;        =&gt; &#039;integer&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
					&#039;default&#039;     =&gt; 0,
				),
				&#039;post&#039;              =&gt; array(
					&#039;description&#039; =&gt; __( &#039;The ID of the associated post object.&#039; ),
					&#039;type&#039;        =&gt; &#039;integer&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039; ),
					&#039;default&#039;     =&gt; 0,
				),
				&#039;status&#039;            =&gt; array(
					&#039;description&#039; =&gt; __( &#039;State of the comment.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039; ),
					&#039;arg_options&#039; =&gt; array(
						&#039;sanitize_callback&#039; =&gt; &#039;sanitize_key&#039;,
					),
				),
				&#039;type&#039;              =&gt; array(
					&#039;description&#039; =&gt; __( &#039;Type of the comment.&#039; ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
					&#039;readonly&#039;    =&gt; true,
				),
			),
		);

		if ( get_option( &#039;show_avatars&#039; ) ) {
			$avatar_properties = array();

			$avatar_sizes = rest_get_avatar_sizes();

			foreach ( $avatar_sizes as $size ) {
				$avatar_properties[ $size ] = array(
					/* translators: %d: Avatar image size in pixels. */
					&#039;description&#039; =&gt; sprintf( __( &#039;Avatar URL with image size of %d pixels.&#039; ), $size ),
					&#039;type&#039;        =&gt; &#039;string&#039;,
					&#039;format&#039;      =&gt; &#039;uri&#039;,
					&#039;context&#039;     =&gt; array( &#039;embed&#039;, &#039;view&#039;, &#039;edit&#039; ),
				);
			}

			$schema[&#039;properties&#039;][&#039;author_avatar_urls&#039;] = array(
				&#039;description&#039; =&gt; __( &#039;Avatar URLs for the comment author.&#039; ),
				&#039;type&#039;        =&gt; &#039;object&#039;,
				&#039;context&#039;     =&gt; array( &#039;view&#039;, &#039;edit&#039;, &#039;embed&#039; ),
				&#039;readonly&#039;    =&gt; true,
				&#039;properties&#039;  =&gt; $avatar_properties,
			);
		}

		$schema[&#039;properties&#039;][&#039;meta&#039;] = $this-&gt;meta-&gt;get_field_schema();

		$this-&gt;schema = $schema;

		return $this-&gt;add_additional_fields_schema( $this-&gt;schema );
	}

	/**
	 * Retrieves the query params for collections.
	 *
	 * @since 4.7.0
	 *
	 * @return array Comments collection parameters.
	 */
	public function get_collection_params() {
		$query_params = parent::get_collection_params();

		$query_params[&#039;context&#039;][&#039;default&#039;] = &#039;view&#039;;

		$query_params[&#039;after&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Limit response to comments published after a given ISO8601 compliant date.&#039; ),
			&#039;type&#039;        =&gt; &#039;string&#039;,
			&#039;format&#039;      =&gt; &#039;date-time&#039;,
		);

		$query_params[&#039;author&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Limit result set to comments assigned to specific user IDs. Requires authorization.&#039; ),
			&#039;type&#039;        =&gt; &#039;array&#039;,
			&#039;items&#039;       =&gt; array(
				&#039;type&#039; =&gt; &#039;integer&#039;,
			),
		);

		$query_params[&#039;author_exclude&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Ensure result set excludes comments assigned to specific user IDs. Requires authorization.&#039; ),
			&#039;type&#039;        =&gt; &#039;array&#039;,
			&#039;items&#039;       =&gt; array(
				&#039;type&#039; =&gt; &#039;integer&#039;,
			),
		);

		$query_params[&#039;author_email&#039;] = array(
			&#039;default&#039;     =&gt; null,
			&#039;description&#039; =&gt; __( &#039;Limit result set to that from a specific author email. Requires authorization.&#039; ),
			&#039;format&#039;      =&gt; &#039;email&#039;,
			&#039;type&#039;        =&gt; &#039;string&#039;,
		);

		$query_params[&#039;before&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Limit response to comments published before a given ISO8601 compliant date.&#039; ),
			&#039;type&#039;        =&gt; &#039;string&#039;,
			&#039;format&#039;      =&gt; &#039;date-time&#039;,
		);

		$query_params[&#039;exclude&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Ensure result set excludes specific IDs.&#039; ),
			&#039;type&#039;        =&gt; &#039;array&#039;,
			&#039;items&#039;       =&gt; array(
				&#039;type&#039; =&gt; &#039;integer&#039;,
			),
			&#039;default&#039;     =&gt; array(),
		);

		$query_params[&#039;include&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Limit result set to specific IDs.&#039; ),
			&#039;type&#039;        =&gt; &#039;array&#039;,
			&#039;items&#039;       =&gt; array(
				&#039;type&#039; =&gt; &#039;integer&#039;,
			),
			&#039;default&#039;     =&gt; array(),
		);

		$query_params[&#039;offset&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Offset the result set by a specific number of items.&#039; ),
			&#039;type&#039;        =&gt; &#039;integer&#039;,
		);

		$query_params[&#039;order&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Order sort attribute ascending or descending.&#039; ),
			&#039;type&#039;        =&gt; &#039;string&#039;,
			&#039;default&#039;     =&gt; &#039;desc&#039;,
			&#039;enum&#039;        =&gt; array(
				&#039;asc&#039;,
				&#039;desc&#039;,
			),
		);

		$query_params[&#039;orderby&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;Sort collection by comment attribute.&#039; ),
			&#039;type&#039;        =&gt; &#039;string&#039;,
			&#039;default&#039;     =&gt; &#039;date_gmt&#039;,
			&#039;enum&#039;        =&gt; array(
				&#039;date&#039;,
				&#039;date_gmt&#039;,
				&#039;id&#039;,
				&#039;include&#039;,
				&#039;post&#039;,
				&#039;parent&#039;,
				&#039;type&#039;,
			),
		);

		$query_params[&#039;parent&#039;] = array(
			&#039;default&#039;     =&gt; array(),
			&#039;description&#039; =&gt; __( &#039;Limit result set to comments of specific parent IDs.&#039; ),
			&#039;type&#039;        =&gt; &#039;array&#039;,
			&#039;items&#039;       =&gt; array(
				&#039;type&#039; =&gt; &#039;integer&#039;,
			),
		);

		$query_params[&#039;parent_exclude&#039;] = array(
			&#039;default&#039;     =&gt; array(),
			&#039;description&#039; =&gt; __( &#039;Ensure result set excludes specific parent IDs.&#039; ),
			&#039;type&#039;        =&gt; &#039;array&#039;,
			&#039;items&#039;       =&gt; array(
				&#039;type&#039; =&gt; &#039;integer&#039;,
			),
		);

		$query_params[&#039;post&#039;] = array(
			&#039;default&#039;     =&gt; array(),
			&#039;description&#039; =&gt; __( &#039;Limit result set to comments assigned to specific post IDs.&#039; ),
			&#039;type&#039;        =&gt; &#039;array&#039;,
			&#039;items&#039;       =&gt; array(
				&#039;type&#039; =&gt; &#039;integer&#039;,
			),
		);

		$query_params[&#039;status&#039;] = array(
			&#039;default&#039;           =&gt; &#039;approve&#039;,
			&#039;description&#039;       =&gt; __( &#039;Limit result set to comments assigned a specific status. Requires authorization.&#039; ),
			&#039;sanitize_callback&#039; =&gt; &#039;sanitize_key&#039;,
			&#039;type&#039;              =&gt; &#039;string&#039;,
			&#039;validate_callback&#039; =&gt; &#039;rest_validate_request_arg&#039;,
		);

		$query_params[&#039;type&#039;] = array(
			&#039;default&#039;           =&gt; &#039;comment&#039;,
			&#039;description&#039;       =&gt; __( &#039;Limit result set to comments assigned a specific type. Requires authorization.&#039; ),
			&#039;sanitize_callback&#039; =&gt; &#039;sanitize_key&#039;,
			&#039;type&#039;              =&gt; &#039;string&#039;,
			&#039;validate_callback&#039; =&gt; &#039;rest_validate_request_arg&#039;,
		);

		$query_params[&#039;password&#039;] = array(
			&#039;description&#039; =&gt; __( &#039;The password for the post if it is password protected.&#039; ),
			&#039;type&#039;        =&gt; &#039;string&#039;,
		);

		/**
		 * Filters REST API collection parameters for the comments controller.
		 *
		 * This filter registers the collection parameter, but does not map the
		 * collection parameter to an internal WP_Comment_Query parameter. Use the
		 * `rest_comment_query` filter to set WP_Comment_Query parameters.
		 *
		 * @since 4.7.0
		 *
		 * @param array $query_params JSON Schema-formatted collection parameters.
		 */
		return apply_filters( &#039;rest_comment_collection_params&#039;, $query_params );
	}

	/**
	 * Sets the comment_status of a given comment object when creating or updating a comment.
	 *
	 * @since 4.7.0
	 *
	 * @param string|int $new_status New comment status.
	 * @param int        $comment_id Comment ID.
	 * @return bool Whether the status was changed.
	 */
	protected function handle_status_param( $new_status, $comment_id ) {
		$old_status = wp_get_comment_status( $comment_id );

		if ( $new_status === $old_status ) {
			return false;
		}

		switch ( $new_status ) {
			case &#039;approved&#039;:
			case &#039;approve&#039;:
			case &#039;1&#039;:
				$changed = wp_set_comment_status( $comment_id, &#039;approve&#039; );
				break;
			case &#039;hold&#039;:
			case &#039;0&#039;:
				$changed = wp_set_comment_status( $comment_id, &#039;hold&#039; );
				break;
			case &#039;spam&#039;:
				$changed = wp_spam_comment( $comment_id );
				break;
			case &#039;unspam&#039;:
				$changed = wp_unspam_comment( $comment_id );
				break;
			case &#039;trash&#039;:
				$changed = wp_trash_comment( $comment_id );
				break;
			case &#039;untrash&#039;:
				$changed = wp_untrash_comment( $comment_id );
				break;
			default:
				$changed = false;
				break;
		}

		return $changed;
	}

	/**
	 * Checks if the post can be read.
	 *
	 * Correctly handles posts with the inherit status.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_Post         $post    Post object.
	 * @param WP_REST_Request $request Request data to check.
	 * @return bool Whether post can be read.
	 */
	protected function check_read_post_permission( $post, $request ) {
		$post_type = get_post_type_object( $post-&gt;post_type );

		// Return false if custom post type doesn&#039;t exist
		if ( ! $post_type ) {
			return false;
		}

		$posts_controller = $post_type-&gt;get_rest_controller();

		/*
		 * Ensure the posts controller is specifically a WP_REST_Posts_Controller instance
		 * before using methods specific to that controller.
		 */
		if ( ! $posts_controller instanceof WP_REST_Posts_Controller ) {
			$posts_controller = new WP_REST_Posts_Controller( $post-&gt;post_type );
		}

		$has_password_filter = false;

		// Only check password if a specific post was queried for or a single comment
		$requested_post    = ! empty( $request[&#039;post&#039;] ) &amp;&amp; ( ! is_array( $request[&#039;post&#039;] ) || 1 === count( $request[&#039;post&#039;] ) );
		$requested_comment = ! empty( $request[&#039;id&#039;] );
		if ( ( $requested_post || $requested_comment ) &amp;&amp; $posts_controller-&gt;can_access_password_content( $post, $request ) ) {
			add_filter( &#039;post_password_required&#039;, &#039;__return_false&#039; );

			$has_password_filter = true;
		}

		if ( post_password_required( $post ) ) {
			$result = current_user_can( &#039;edit_post&#039;, $post-&gt;ID );
		} else {
			$result = $posts_controller-&gt;check_read_permission( $post );
		}

		if ( $has_password_filter ) {
			remove_filter( &#039;post_password_required&#039;, &#039;__return_false&#039; );
		}

		return $result;
	}

	/**
	 * Checks if the comment can be read.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_Comment      $comment Comment object.
	 * @param WP_REST_Request $request Request data to check.
	 * @return bool Whether the comment can be read.
	 */
	protected function check_read_permission( $comment, $request ) {
		if ( ! empty( $comment-&gt;comment_post_ID ) ) {
			$post = get_post( $comment-&gt;comment_post_ID );
			if ( $post ) {
				if ( $this-&gt;check_read_post_permission( $post, $request ) &amp;&amp; 1 === (int) $comment-&gt;comment_approved ) {
					return true;
				}
			}
		}

		if ( 0 === get_current_user_id() ) {
			return false;
		}

		if ( empty( $comment-&gt;comment_post_ID ) &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
			return false;
		}

		if ( ! empty( $comment-&gt;user_id ) &amp;&amp; get_current_user_id() === (int) $comment-&gt;user_id ) {
			return true;
		}

		return current_user_can( &#039;edit_comment&#039;, $comment-&gt;comment_ID );
	}

	/**
	 * Checks if a comment can be edited or deleted.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_Comment $comment Comment object.
	 * @return bool Whether the comment can be edited or deleted.
	 */
	protected function check_edit_permission( $comment ) {
		if ( 0 === (int) get_current_user_id() ) {
			return false;
		}

		if ( current_user_can( &#039;moderate_comments&#039; ) ) {
			return true;
		}

		return current_user_can( &#039;edit_comment&#039;, $comment-&gt;comment_ID );
	}

	/**
	 * Checks a comment author email for validity.
	 *
	 * Accepts either a valid email address or empty string as a valid comment
	 * author email address. Setting the comment author email to an empty
	 * string is allowed when a comment is being updated.
	 *
	 * @since 4.7.0
	 *
	 * @param string          $value   Author email value submitted.
	 * @param WP_REST_Request $request Full details about the request.
	 * @param string          $param   The parameter name.
	 * @return string|WP_Error The sanitized email address, if valid,
	 *                         otherwise an error.
	 */
	public function check_comment_author_email( $value, $request, $param ) {
		$email = (string) $value;
		if ( empty( $email ) ) {
			return $email;
		}

		$check_email = rest_validate_request_arg( $email, $request, $param );
		if ( is_wp_error( $check_email ) ) {
			return $check_email;
		}

		return $email;
	}

	/**
	 * If empty comments are not allowed, checks if the provided comment content is not empty.
	 *
	 * @since 5.6.0
	 *
	 * @param array $prepared_comment The prepared comment data.
	 * @return bool True if the content is allowed, false otherwise.
	 */
	protected function check_is_comment_content_allowed( $prepared_comment ) {
		$check = wp_parse_args(
			$prepared_comment,
			array(
				&#039;comment_post_ID&#039;      =&gt; 0,
				&#039;comment_author&#039;       =&gt; null,
				&#039;comment_author_email&#039; =&gt; null,
				&#039;comment_author_url&#039;   =&gt; null,
				&#039;comment_parent&#039;       =&gt; 0,
				&#039;user_id&#039;              =&gt; 0,
			)
		);

		/** This filter is documented in wp-includes/comment.php */
		$allow_empty = apply_filters( &#039;allow_empty_comment&#039;, false, $check );

		if ( $allow_empty ) {
			return true;
		}

		/*
		 * Do not allow a comment to be created with missing or empty
		 * comment_content. See wp_handle_comment_submission().
		 */
		return &#039;&#039; !== $check[&#039;comment_content&#039;];
	}
}
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes%2Frest-api'>?? Yukar?</a>