Changeset 14541

Timestamp:

09/26/2025 06:51:30 PM (10 hours ago)

Author:

coffee2code

Message:

Photo Directory, Tags: Fix and improve tag merging.

• Split merging and rename handling
• Add helper function for explicit rename/merge
• Add support for rename/merge via Quick Edit
• Improve admin notice handling
• Hide new tag form since tags shouldn't be directly created
• Prevent direct new tag creation from tags listing

File:

• sites/trunk/wordpress.org/public_html/wp-content/plugins/photo-directory/inc/tags.php (modified) (9 diffs)

sites/trunk/wordpress.org/public_html/wp-content/plugins/photo-directory/inc/tags.php

@@ -16 +16 @@
     private static $processing_merge = false;
 
-    /** @var array The old terms. */
-    protected static $old_terms = [];
-
     /** @var string[] Memoized array of taxonomies that have merge functionality enabled, as determined by `get_mergeable_taxonomies()`. */
     protected static $mergeable_taxonomies = [];
@@ -38 +35 @@
         add_filter( 'pre_insert_term', [ __CLASS__, 'prevent_remapped_term_creation' ], 10, 3 );
 
+        // Handle quick edit merge.
+        add_action( 'wp_ajax_inline-save-tax',      [ __CLASS__, 'maybe_handle_quick_edit_merge' ], 1 );
+
         if ( is_admin() ) {
             self::init_admin();
@@ -49 +49 @@
         foreach ( self::get_mergeable_taxonomies() as $taxonomy ) {
             add_action( "{$taxonomy}_edit_form_fields", [ __CLASS__, 'inject_custom_slug_description' ], 20, 2 );
-            add_action( "edit_{$taxonomy}",             [ __CLASS__, 'capture_old_slug' ], 1, 2 );
-            add_action( "edited_{$taxonomy}",           [ __CLASS__, 'process_merge_rename' ], 10, 2 );
+            add_action( "edited_{$taxonomy}",           [ __CLASS__, 'process_rename' ], 10, 2 );
         }
         add_action( 'admin_notices',              [ __CLASS__, 'admin_notices' ] );
+        add_action( 'load-edit-tags.php',         [ __CLASS__, 'maybe_handle_term_merge_submit' ] );
         add_filter( 'redirect_term_location',     [ __CLASS__, 'maybe_redirect_merged_term' ], 10, 2 );
+
+        // Hide the new tag form and prevent direct tag creation.
+        add_action( "{$taxonomy}_add_form",       [ __CLASS__, 'hide_add_tag_form' ], 1 );
+        add_filter( 'pre_insert_term',            [ __CLASS__, 'prevent_direct_tag_creation' ], 10, 3 );
     }
 
@@ -109 +113 @@
 
     /**
-     * Stores the name and slug of term being edited before changes are saved.
+     * Hides the new tag form for mergeable taxonomies.
+     *
+     * @param string $taxonomy The taxonomy slug.
+     */
+    public static function hide_add_tag_form( $taxonomy ) {
+        if (
+            self::is_mergeable_taxonomy( $taxonomy )
+            && isset( $_GET['post_type'] )
+            && Registrations::get_post_type() === $_GET['post_type']
+        ) {
+            echo '<style>#col-left { display: none !important; } #col-right { float: none !important; width: 100% !important; }</style>';
+        }
+    }
+
+    /**
+     * Prevents direct tag creation for mergeable taxonomies.
+     *
+     * @param mixed  $term     The term data.
+     * @param string $taxonomy The taxonomy.
+     * @param array  $args     Additional arguments.
+     * @return mixed|WP_Error The term data or WP_Error to prevent creation.
+     */
+    public static function prevent_direct_tag_creation( $term, $taxonomy, $args ) {
+        if ( self::is_mergeable_taxonomy( $taxonomy ) ) {
+            $post_type = $_POST['post_type'] ?? '';
+            $photo_post_type = Registrations::get_post_type();
+            // Check if this is coming from the add tag form (and not programmatic).
+            if (
+                wp_doing_ajax()
+                && isset( $_POST['action'] )
+                && 'add-tag' === $_POST['action']
+                && $photo_post_type === $post_type
+            ) {
+                return new \WP_Error( 'tag_creation_disabled',
+                    __( 'Direct tag creation is disabled. Please use the merge functionality instead.', 'wporg-photos' )
+                );
+            }
+        }
+
+        return $term;
+    }
+
+    /**
+     * Handles tag rename.
      *
      * @param int $term_id The ID of the term just edited.
      * @param int $tt_id   The term taxonomy ID.
      */
-    public static function capture_old_slug( $term_id, $tt_id ) {
+    public static function process_rename( $term_id, $tt_id ) {
         // Get taxonomy from the term.
         $term = get_term( $term_id );
@@ -122 +169 @@
         $taxonomy = $term->taxonomy;
 
-        if ( ! self::is_mergeable_taxonomy( $taxonomy ) ) {
-            return;
-        }
-
-        self::$old_terms[ $taxonomy ][ $term_id ] = [
-            'name' => $term->name,
-            'slug' => $term->slug,
-        ];
-    }
-
-    /**
-     * Handles tag merge/rename.
-     *
-     * @param int $term_id The ID of the term just edited.
-     * @param int $tt_id   The term taxonomy ID.
-     */
-    public static function process_merge_rename( $term_id, $tt_id ) {
-        // Bail if function has already been invoked (prevents recursion).
-        if ( self::$processing_merge ) {
-            return;
-        }
-
-        // Get taxonomy from the term.
-        $term = get_term( $term_id );
-        if ( ! $term instanceof \WP_Term ) {
-            return;
-        }
-        $taxonomy = $term->taxonomy;
-
         // Bail if not a mergeable taxonomy.
         if ( ! self::is_mergeable_taxonomy( $taxonomy ) ) {
@@ -156 +174 @@
         }
 
+        // Get the old slug and count from the transient.
+        $key  = self::pre_rename_key( $taxonomy, $term_id );
+        $data = get_transient( $key );
+
+        // Bail if there was no pre-rename note.
+        if ( false === $data || ! is_array( $data ) ) {
+            return;
+        }
+
+        // Remove the transient.
+        delete_transient( $key );
+
         // Old term data was captured earlier.
-        $old_data = self::$old_terms[ $taxonomy ][ $term_id ] ?? [ 'name' => '', 'slug' => '' ];
-        $old_name = $old_data['name'];
-        $old_slug = $old_data['slug'];
-
-        // Get new term data.
-        $new_slug = ( $term instanceof \WP_Term ) ? $term->slug : '';
-        $new_name = ( $term instanceof \WP_Term ) ? $term->name : '';
-
-        // Mimic core and auto-generate slug from name if no slug was provided.
+        $old_slug  = isset( $data['old_slug'] ) ? sanitize_title( $data['old_slug'] ) : '';
+        $old_count = isset( $data['count'] ) ? (int) $data['count'] : 0;
+        $new_slug  = $term->slug;
+
+        // Only act when slug actually changed and the old term had posts.
+        if ( $old_slug && $new_slug && $old_slug !== $new_slug && $old_count > 0 ) {
+            self::add_slug_redirect( $old_slug, $new_slug, $taxonomy );
+        }
+    }
+
+    /**
+     * Handles merging tags and setting a redirect when the user attempts to rename
+     * a term to a slug that already exists.
+     */
+    public static function maybe_handle_term_merge_submit() {
+        // Bail if merge is already in progress.
+        if ( self::$processing_merge ) {
+            return;
+        }
+
+        // Bail if not a POST request.
+        if ( 'POST' !== $_SERVER['REQUEST_METHOD'] ) {
+            return;
+        }
+
+        // Bail if not an edited tag request.
+        if ( empty( $_POST['action'] ) || 'editedtag' !== $_POST['action'] ) {
+            return;
+        }
+
+        // Bail if not a mergeable taxonomy.
+        $taxonomy = isset( $_POST['taxonomy'] ) ? sanitize_key( $_POST['taxonomy'] ) : '';
+        if ( ! self::is_mergeable_taxonomy( $taxonomy ) ) {
+            return;
+        }
+
+        // Bail if no from term ID.
+        $from_term_id = isset( $_POST['tag_ID'] ) ? (int) $_POST['tag_ID'] : 0;
+        if ( $from_term_id <= 0 ) {
+            return;
+        }
+
+        // Bail if user doesn't have the capability.
+        if ( ! current_user_can( 'edit_term', $from_term_id ) ) {
+            return;
+        }
+        check_admin_referer( 'update-tag_' . $from_term_id );
+
+        $new_slug_raw = isset( $_POST['slug'] ) ? wp_unslash( $_POST['slug'] ) : '';
+        $new_slug     = sanitize_title( $new_slug_raw );
+
+        // Bail if the slug field was not changed or is empty.
         if ( '' === $new_slug ) {
-            $new_slug = sanitize_title( $new_name );
-        }
-
-        // Bail if no change in slug.
-        if ( ! $new_slug || $old_slug === $new_slug ) {
-            return;
-        }
-
-        // Check if target tag exists.
+            return;
+        }
+
+        // Bail if from term doesn't exist.
+        $from = get_term( $from_term_id, $taxonomy );
+        if ( ! $from || is_wp_error( $from ) ) {
+            return;
+        }
+
+        // Bail if user didn't actually change the slug.
+        if ( $new_slug === $from->slug ) {
+            return;
+        }
+
+        // Bail if the term doesn't exist.
         $exists = term_exists( $new_slug, $taxonomy );
+        if ( ! $exists || is_wp_error( $exists ) ) {
+            // Queue up a transient to store the old slug and count for later use by `process_rename()`.
+            set_transient(
+                self::pre_rename_key( $taxonomy, $from_term_id ),
+                [
+                    'old_slug' => $from->slug,
+                    'count'    => (int) $from->count,
+                ],
+                5 * MINUTE_IN_SECONDS
+            );
+
+            // Let core handle the new, unique slug.
+            return;
+        }
+
+        // Bail if the term ID is invalid.
         $to_term_id = is_array( $exists ) ? (int) $exists['term_id'] : (int) $exists;
-
+        if ( $to_term_id <= 0 || $to_term_id === $from_term_id ) {
+            return;
+        }
+
+        // Keep the old before we mutate/delete it.
+        $old_slug   = $from->slug;
+        $old_count  = (int) $from->count;
+        $to         = get_term( $to_term_id, $taxonomy );
+        $to_name    = $to && ! is_wp_error( $to ) ? $to->name : '';
+
+        // Merge terms.
         self::$processing_merge = true;
-
-        // Merge terms if target term exists.
-        if ( $to_term_id && $to_term_id !== $term_id ) {
-            self::merge_terms( $term_id, $to_term_id, $taxonomy );
-            $new_term = get_term( $to_term_id, $taxonomy );
-
-            self::add_slug_redirect( $old_slug, $new_term->slug, $taxonomy );
-
-            set_transient( "photo_directory_tag_merge_redirect_{$term_id}", $to_term_id, 60 );
-
-            $message = sprintf(
-                /* translators: 1: Old term, 2: Existing term */
-                __( 'Merged term <strong>%1$s</strong> into <strong>%2$s</strong>.', 'wporg-photos' ),
-                esc_html( $old_name ),
-                esc_html( $new_term->name )
+        self::merge_terms( $from_term_id, $to_term_id, $taxonomy );
+
+        // Add redirect only if the old term actually had posts assigned.
+        if ( $old_count > 0 ) {
+            self::add_slug_redirect( $old_slug, $to->slug, $taxonomy );
+        }
+
+        self::queue_admin_notice( [
+            'type' => 'success',
+            'message' => sprintf(
+                /* translators: 1: Old term name, 2: New/existing term name */
+                __( 'Merged term "%1$s" into "%2$s".', 'wporg-photos' ),
+                $from->name,
+                $to_name
+            )
+        ] );
+
+        // Redirect to surviving term’s edit screen, skipping core's updater.
+        $location = add_query_arg(
+            [
+                'action'   => 'edit',
+                'post_type' => Registrations::get_post_type(),
+                'taxonomy' => $taxonomy,
+                'tag_ID'   => $to_term_id,
+            ],
+            admin_url( 'term.php' )
+        );
+        wp_safe_redirect( $location );
+        exit;
+    }
+
+    /**
+     * Handles quick edit merge.
+     */
+    public static function maybe_handle_quick_edit_merge() {
+        // Security and context checks mirror core.
+        check_ajax_referer( 'taxinlineeditnonce', '_inline_edit' );
+
+        // Bail if merge is already in progress.
+        if ( self::$processing_merge ) {
+            return;
+        }
+
+        // Bail if not a mergeable taxonomy.
+        $taxonomy = isset( $_POST['taxonomy'] ) ? sanitize_key( $_POST['taxonomy'] ) : '';
+        if ( ! self::is_mergeable_taxonomy( $taxonomy ) ) {
+            return; // Let core proceed.
+        }
+
+        // Bail if no from term ID.
+        $from_id = isset( $_POST['tax_ID'] ) ? (int) $_POST['tax_ID'] : 0;
+        if ( $from_id <= 0 || ! current_user_can( 'edit_term', $from_id ) ) {
+            return;
+        }
+
+        // Bail if from term doesn't exist.
+        $from = get_term( $from_id, $taxonomy );
+        if ( ! $from || is_wp_error( $from ) ) {
+            return;
+        }
+
+        $new_slug_raw = isset( $_POST['slug'] ) ? wp_unslash( $_POST['slug'] ) : '';
+        $new_slug     = sanitize_title( $new_slug_raw );
+
+        // Bail if the slug field was not changed or is empty.
+        if ( '' === $new_slug || $new_slug === $from->slug ) {
+            return;
+        }
+
+        $exists = term_exists( $new_slug, $taxonomy );
+
+        // Bail if no existing term, but stash old slug/count so process_rename() can add a redirect.
+        if ( ! $exists || is_wp_error( $exists ) ) {
+            set_transient(
+                self::pre_rename_key( $taxonomy, $from_id ),
+                [
+                    'old_slug' => $from->slug,
+                    'count'    => (int) $from->count,
+                ],
+                5 * MINUTE_IN_SECONDS
             );
-
-        // Else just rename existing term.
-        } else {
-            $updated = wp_update_term( $term_id, $taxonomy, [
-                'name' => $new_name,
-                'slug' => $new_slug,
-            ] );
-
-            if ( is_wp_error( $updated ) ) {
-                $message = $updated->get_error_message();
-            } else {
-                // Only create redirect if the tag has posts.
-                if ( $term->count > 0 ) {
-                    self::add_slug_redirect( $old_slug, $new_slug, $taxonomy );
-                }
-
-                $message = sprintf(
-                    /* translators: %s: New term name */
-                    __( 'Changed term slug to <strong>%s</strong>.', 'wporg-photos' ),
-                    esc_html( $new_name )
-                );
+            // Core's wp_ajax_inline_save_tax() will perform wp_update_term().
+            return;
+        }
+
+        // Bail if the to term ID is invalid or the same as the from term ID.
+        $to_id = is_array( $exists ) ? (int) $exists['term_id'] : (int) $exists;
+        if ( $to_id <= 0 || $to_id === $from_id ) {
+            return;
+        }
+
+        // Perform merge and produce the same kind of response core would.
+        $old_count = (int) $from->count;
+        self::$processing_merge = true;
+        self::merge_terms( $from_id, $to_id, $taxonomy );
+
+        if ( $old_count > 0 ) {
+            $to_slug = get_term_field( 'slug', $to_id, $taxonomy );
+            if ( ! is_wp_error( $to_slug ) && $to_slug ) {
+                self::add_slug_redirect( $from->slug, $to_slug, $taxonomy );
             }
         }
 
-        // Queue up an admin notice.
-        set_transient( 'photo_directory_tag_merge_admin_notice', $message, 30 );
-
-        self::$processing_merge = false;
-
-        return;
+        // Render the updated row HTML for the surviving term, just like core does.
+        $tag           = get_term( $to_id, $taxonomy );
+        $wp_list_table = _get_list_table( 'WP_Terms_List_Table', [ 'screen' => 'edit-' . $taxonomy ] );
+
+        // Compute level for hierarchical taxonomies (tags will just be level 0).
+        $level  = 0;
+        $parent = $tag && ! is_wp_error( $tag ) ? (int) $tag->parent : 0;
+        while ( $parent > 0 ) {
+            $parent_tag = get_term( $parent, $taxonomy );
+            $parent     = $parent_tag ? (int) $parent_tag->parent : 0;
+            ++$level;
+        }
+
+        $wp_list_table->single_row( $tag, $level );
+        // Stop core's default AJAX handler from running.
+        wp_die();
+    }
+
+    /**
+     * Generates a transient key for pre-rename data.
+     *
+     * @param string $taxonomy The taxonomy slug.
+     * @param int    $term_id  The term ID.
+     * @return string The transient key.
+     */
+    protected static function pre_rename_key( $taxonomy, $term_id ) {
+        return "photos_tags_pre_rename_{$taxonomy}_{$term_id}";
     }
 
@@ -248 +437 @@
 
         foreach ( $object_ids as $object_id ) {
-            wp_remove_object_terms( $object_id, $from_term_id, $taxonomy );
-            wp_add_object_terms( $object_id, $to_term_id, $taxonomy );
+            wp_add_object_terms( $object_id, [ $to_term_id ], $taxonomy );
+            wp_remove_object_terms( $object_id, [ $from_term_id ], $taxonomy );
         }
 
@@ -257 +446 @@
 
     /**
+     * Queues an admin notice.
+     *
+     * @param string $message The message to queue.
+     */
+    public static function queue_admin_notice( $message ) {
+        set_transient( 'photo_directory_tag_merge_admin_notice', $message, 30 );
+    }
+
+    /**
      * Outputs admin notice if one is queued.
      */
     public static function admin_notices() {
-        if ( $msg = get_transient( 'photo_directory_tag_merge_admin_notice' ) ) {
-            printf(
-                '<div class="notice notice-success is-dismissible"><p>%s</p></div>',
-                wp_kses_post( $msg )
-            );
-            delete_transient( 'photo_directory_tag_merge_admin_notice' );
-        }
+        $data = get_transient( 'photo_directory_tag_merge_admin_notice' );
+        if ( ! $data ) {
+            return;
+        }
+        delete_transient( 'photo_directory_tag_merge_admin_notice' );
+
+        $type    = in_array( $data['type'], [ 'success', 'warning', 'error', 'info' ], true ) ? $data['type'] : 'success';
+        $message = $data['message'];
+
+        printf(
+            '<div class="notice notice-%1$s is-dismissible"><p>%2$s</p></div>',
+            esc_attr( $type ),
+            wp_kses_post( $message )
+        );
     }
 
@@ -582 +787 @@
     }
 
+    /**
+     * API function to rename or merge tags.
+     *
+     * Use this instead of `wp_update_term()` to "rename to existing slug = merge".
+     *
+     * @return array|WP_Error Result of `wp_update_term()` on simple rename, or ['merged' => true, 'to_term_id' => X] on merge.
+     */
+    public static function rename_or_merge( int $term_id, string $taxonomy, string $new_slug ) {
+        // Bail if not a mergeable taxonomy.
+        if ( ! self::is_mergeable_taxonomy( $taxonomy ) ) {
+            return new WP_Error( 'invalid_taxonomy', __( 'Taxonomy is not merge-enabled.', 'your-textdomain' ) );
+        }
+
+        $new_slug = sanitize_title( $new_slug );
+        $from     = get_term( $term_id, $taxonomy );
+
+        // Bail if the term doesn't exist.
+        if ( ! $from || is_wp_error( $from ) ) {
+            return new WP_Error( 'invalid_term', __( 'Term not found.', 'wporg-photos' ) );
+        }
+
+        // Bail if the new slug is the same as the old slug.
+        if ( '' === $new_slug || $new_slug === $from->slug ) {
+            // Nothing to do.
+            return [ 'term_id' => $term_id ];
+        }
+
+        // Handle a merge.
+        $exists = term_exists( $new_slug, $taxonomy );
+        if ( $exists && ! is_wp_error( $exists ) ) {
+            $to_term_id = is_array( $exists ) ? (int) $exists['term_id'] : (int) $exists;
+            if ( $to_term_id && $to_term_id !== $term_id ) {
+                if ( self::$processing_merge ) {
+                    return new WP_Error( 'reentrancy', __( 'Merge already in progress.', 'wporg-photos' ) );
+                }
+                self::$processing_merge = true;
+
+                $old_count = (int) $from->count;
+                $old_slug  = $from->slug;
+                self::merge_terms( $term_id, $to_term_id, $taxonomy );
+
+                if ( $old_count > 0 ) {
+                    $to = get_term( $to_term_id, $taxonomy );
+                    if ( $to && ! is_wp_error( $to ) ) {
+                        self::add_slug_redirect( $old_slug, $to->slug, $taxonomy );
+                    }
+                }
+
+                self::$processing_merge = false;
+                return [ 'merged' => true, 'to_term_id' => $to_term_id ];
+            }
+        }
+
+        // Handle a simple rename.
+        $result = wp_update_term( $term_id, $taxonomy, [ 'slug' => $new_slug ] );
+        if ( is_wp_error( $result ) ) {
+            return $result;
+        }
+
+        // Optional: add redirect if old term had posts.
+        if ( (int) $from->count > 0 ) {
+            self::add_slug_redirect( $from->slug, $new_slug, $taxonomy );
+        }
+
+        return $result;
+    }
+
 }