File Type/TermObject/Mutation/TermObjectDelete.php

  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

<?php

namespace WPGraphQL\Type\PostObject\Mutation;

use GraphQL\Error\UserError;
use GraphQLRelay\Relay;
use WPGraphQL\Types;

class TermObjectDelete {

    /**
     * Holds the mutation field definition
     *
     * @var array $mutation
     */
    private static $mutation = [];

    /**
     * Defines the update mutation for TermObjects
     *
     * @param \WP_Taxonomy $taxonomy
     *
     * @return array|mixed
     */
    public static function mutate( \WP_Taxonomy $taxonomy ) {

        if ( ! empty( $taxonomy->graphql_single_name ) && empty( self::$mutation[ $taxonomy->graphql_single_name ] ) ) :

            /**
             * Set the name of the mutation being performed
             */
            $mutation_name = 'Delete' . ucwords( $taxonomy->graphql_single_name );

            self::$mutation[ $taxonomy->graphql_single_name ] = Relay::mutationWithClientMutationId([
                'name' => esc_html( $mutation_name ),
                // Translators: The placeholder is the taxonomy name of the term being deleted
                'description' => sprintf( esc_html__( 'Delete %1$s objects', 'wp-graphql' ), $taxonomy->graphql_single_name ),
                'inputFields' => [
                    'id' => [
                        'type' => Types::non_null( Types::id() ),
                        // translators: The placeholder is the name of the taxonomy for the term being deleted
                        'description' => sprintf( __( 'The ID of the %1$s to delete', 'wp-graphql' ), $taxonomy->graphql_single_name ),
                    ],
                ],
                'outputFields' => [
                    'deletedId' => [
                        'type' => Types::id(),
                        'description' => __( 'The ID of the deleted object', 'wp-graphql' ),
                        'resolve' => function( $payload ) use ( $taxonomy ) {
                            $deleted = (object) $payload['termObject'];
                            return ! empty( $deleted->term_id ) ? Relay::toGlobalId( $taxonomy->name, $deleted->term_id ) : null;
                        },
                    ],
                    $taxonomy->graphql_single_name => [
                        'type' => Types::term_object( $taxonomy->name ),
                        'description' => __( 'The object before it was deleted', 'wp-graphql' ),
                        'resolve' => function( $payload ) use ( $taxonomy ) {
                            $deleted = (object) $payload['termObject'];
                            return ! empty( $deleted ) ? $deleted : null;
                        },
                    ],
                ],
                'mutateAndGetPayload' => function( $input ) use ( $taxonomy, $mutation_name ) {

                    $id_parts = Relay::fromGlobalId( $input['id'] );

                    if ( ! empty( $id_parts['id'] ) && absint( $id_parts['id'] ) ) {
                        $term_id = absint( $id_parts['id'] );
                    } else {
                        // Translators: The placeholder is the name of the taxonomy for the term being deleted
                        throw new UserError( sprintf( __( 'The ID for the %1$s was not valid', 'wp-graphql' ), $taxonomy->graphql_single_name ) );
                    }

                    /**
                     * Ensure the type for the Global ID matches the type being mutated
                     */
                    if ( empty( $id_parts['type'] ) || $taxonomy->name !== $id_parts['type'] ) {
                        // Translators: The placeholder is the name of the taxonomy for the term being edited
                        throw new UserError( sprintf( __( 'The ID passed is not for a %1$s object', 'wp-graphql' ), $taxonomy->graphql_single_name ) );
                    }

                    /**
                     * Get the term before deleting it
                     */
                    $term_object = get_term( $term_id, $taxonomy->name );

                    /**
                     * Ensure the user can delete terms of this taxonomy
                     */
                    if ( ! current_user_can( 'delete_term', $term_object->term_id ) ) {
                        // Translators: The placeholder is the name of the taxonomy for the term being deleted
                        throw new UserError( sprintf( __( 'You do not have permission to delete %1$s', 'wp-graphql' ), $taxonomy->graphql_plural_name ) );
                    }

                    /**
                     * Delete the term and get the response
                     */
                    $deleted = wp_delete_term( $term_id, $taxonomy->name );

                    /**
                     * If there was an error deleting the term, get the error message and return it
                     */
                    if ( is_wp_error( $deleted ) ) {
                        $error_message = $deleted->get_error_message();
                        if ( ! empty( $error_message ) ) {
                            throw new UserError( esc_html( $error_message ) );
                        } else {
                            // Translators: The placeholder is the name of the taxonomy for the term being deleted
                            throw new UserError( sprintf( __( 'The %1$s failed to delete but no error was provided', 'wp-graphql' ), $taxonomy->name ) );
                        }
                    }

                    /**
                     * Return the term object that was retrieved prior to deletion
                     */
                    return [
                        'termObject' => $term_object,
                    ];

                },
            ]);

        endif; // End if().

        return ! empty( self::$mutation[ $taxonomy->graphql_single_name ] ) ? self::$mutation[ $taxonomy->graphql_single_name ] : null;

    }
}

Namespaces

Classes

Interfaces