[Feature Request] Problema con las importaciones y traducciones automatizadas

<?php

namespace WPML\Import\Commands;

use WPML\Collect\Support\Collection;
use WPML\Import\Commands\Base\Query;
use WPML\Import\Fields;

// phpcs:disable WordPress.DB.PreparedSQL.NotPrepared
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared

class FixImportedPostSlugs implements Base\Command {

	use Query;

	/**
	 * Optional meta key for import tools that map a "Slug" column into post meta.
	 */
	const DESIRED_SLUG_META = '_wpml_import_desired_slug';
	const DUPLICATE_OF_META = '_icl_lang_duplicate_of';
	const DUPLICATE_STATUS_META = '_icl_lang_duplicate_status';

	const DEFAULT_LIMIT = 50;

	/** @var \wpdb */
	protected $wpdb;

	/** @var string|null */
	private $forcedSlug = null;

	/** @var int|null */
	private $forcedPostId = null;



	public function __construct( \wpdb $wpdb ) {
		$this->wpdb = $wpdb;
	}

	public static function getTitle() {
		return __( 'Fixing Imported Post Slugs', 'wpml-import' );
	}

	public static function getDescription() {
		return __( 'Normalize imported translation slugs to match their WPML source post slug.', 'wpml-import' );
	}

	public function countPendingItems( Collection $args = null ) {
		return count( $this->getPendingItems() );
	}

	public function run( Collection $args = null ) {
		$items = $this->getPendingItems( self::DEFAULT_LIMIT );

		if ( empty( $items ) ) {
			return 0;
		}

		// Prevent WP from re-suffixing while we intentionally align translation slugs.
		add_filter( 'pre_wp_unique_post_slug', [ $this, 'preUniqueSlug' ], 10, 6 );

		foreach ( $items as $item ) {
			$postId = (int) $item->post_id;

			if ( ! $postId ) {
				continue;
			}

			$current     = sanitize_title( (string) get_post_field( 'post_name', $postId ) );
			$slugToApply = sanitize_title( (string) $item->source_slug );

			if ( '' === $slugToApply || '' === $current ) {
				$this->cleanupDuplicateMeta( $postId );
				$this->cleanupMeta( $postId );
				continue;
			}

			if ( $current !== $slugToApply ) {
				$this->forcedSlug   = $slugToApply;
				$this->forcedPostId = $postId;

				$res = wp_update_post([ 
					'ID' => $postId, 
					'post_name' => $slugToApply 
					], 
					true);

				$this->forcedSlug   = null;
				$this->forcedPostId = null;

				$this->cleanupOldSlugMeta( $postId );
			}

			$this->cleanupDuplicateMeta( $postId );
			$this->cleanupMeta( $postId );
		}

		remove_filter( 'pre_wp_unique_post_slug', [ $this, 'preUniqueSlug' ], 10 );

		return count( $items );
	}

	/**
	 * Short-circuit WP slug uniqueness only while we are forcing a slug.
	 */

	public function preUniqueSlug( $override, $slug, $post_ID, $post_status, $post_type, $post_parent ) {
		if ( ! $this->forcedSlug || (int) $post_ID !== (int) $this->forcedPostId ) {
			return $override;
		}

		// Attachments excluded by query, but keep it defensive.
		if ( 'attachment' === $post_type ) {
			return $override;
		}

		$obj = get_post_type_object( $post_type );
		$isHierarchical = $obj && ! empty( $obj->hierarchical );

		if ( $isHierarchical ) {
			// If a sibling already has that slug, let WP generate a unique one.
			$exists = $this->wpdb->get_var(
				$this->wpdb->prepare(
					"
					SELECT ID FROM {$this->wpdb->posts}
					WHERE post_type = %s
					AND post_parent = %d
					AND post_name = %s
					AND ID <> %d
					LIMIT 1
					",
					$post_type,
					(int) $post_parent,
					$this->forcedSlug,
					(int) $post_ID
				)
			);

			if ( $exists ) {
				return $override; // let WP suffix
			}
		}

		return $this->forcedSlug;
	}

	private function cleanupMeta( $postId ) {
		if ( $postId ) {
			delete_post_meta( $postId, self::DESIRED_SLUG_META );
		}
	}

	/**
	 * Prevent WordPress canonical redirects based on historical slugs after normalization.
	 */
	private function cleanupOldSlugMeta( $postId ) {
		if ( $postId ) {
			delete_post_meta( $postId, '_wp_old_slug' );
			delete_post_meta( $postId, '_wp_old_date' );
		}
	}

	/**
	 * Ensure imported translations are not kept as "duplicates of original" by WPML.
	 */
	private function cleanupDuplicateMeta( $postId ) {
		if ( $postId ) {
			delete_post_meta( $postId, self::DUPLICATE_OF_META );
			delete_post_meta( $postId, self::DUPLICATE_STATUS_META );
		}
	}

	/**
	 * Returns imported posts that need slug normalization.
	 */
	private function getPendingItems( $limit = null ) {
		return $this->getResultsWithLimit(
			"
			SELECT
				tr.element_id AS post_id,
				sourcePost.post_name AS source_slug
			FROM {$this->wpdb->prefix}icl_translations tr
			INNER JOIN {$this->wpdb->postmeta} pm
				ON pm.post_id = tr.element_id
				AND pm.meta_key = '" . Fields::TRANSLATION_GROUP . "'
			INNER JOIN {$this->wpdb->prefix}icl_translations sourceTr
				ON sourceTr.trid = tr.trid
				AND sourceTr.element_type = tr.element_type
				AND COALESCE(sourceTr.source_language_code, '') = ''
			INNER JOIN {$this->wpdb->posts} post
				ON post.ID = tr.element_id
			INNER JOIN {$this->wpdb->posts} sourcePost
				ON sourcePost.ID = sourceTr.element_id
			LEFT JOIN {$this->wpdb->postmeta} duplicateMeta
				ON duplicateMeta.post_id = tr.element_id
				AND duplicateMeta.meta_key = '" . self::DUPLICATE_OF_META . "'
			WHERE tr.element_type LIKE '" . $this->wpdb->esc_like( 'post_' ) . "%'
				AND tr.element_type <> 'post_attachment'
				AND COALESCE(tr.source_language_code, '') <> ''
				AND (
					post.post_name <> sourcePost.post_name
					OR NULLIF(duplicateMeta.meta_value, '') IS NOT NULL
				)				
			ORDER BY tr.element_id ASC
			",
			$limit
		);
	}
}

public static function getProcessCommands( $context ) {
		$processCommands = [
			SetTermsLanguage::class,
			SetPostsLanguage::class,
		  FixImportedPostSlugs::class,
		  ...