Permaliens — un défaut * invisible au développeur, qui flushe sans y penser en testant. */ const VERSION_REGLES = '2'; /** * Singleton instance. * * @var self|null */ private static $instance = null; /** * @return self */ public static function get_instance(): self { if ( null === self::$instance ) { self::$instance = new self(); } return self::$instance; } /** * @return void */ public function register_hooks(): void { /** * Intercepteur précoce : sert le XML avant qu'un autre plugin SEO (Yoast, * Rank Math…) ne capture l'URL « *-sitemap.xml ». La règle de réécriture * ci-dessous reste en repli pour les sites sans plugin SEO concurrent. * * ⛔⛔ LA PRIORITÉ EST PASSÉE DE 0 À 99 LE 28/08/2026, ET C'EST LA CAUSE DES 85 % * QUI MANQUAIENT — pas les réglages, pas le cache, pas les taxonomies en dur. * * WooCommerce enregistre `product`, `product_cat`, `product_brand` et ses 51 * attributs `pa_*` sur `init` PRIORITÉ 5. À la priorité 0, tout ça n'existe pas * encore : `post_type_exists( 'product' )` et `taxonomy_exists( 'product_cat' )` * rendent FALSE, et le générateur — qui filtre correctement par ces deux * fonctions — les écarte en silence. * * Mesuré sur apsis.fr, avec des réglages PARFAITS en base * (`post_types: [post, page, product]`, 57 taxonomies dont les `pa_*`) : * l'index rendait 3 groupes — post, page, category. Les seuls que WordPress * enregistre AVANT `init`. * 29 adresses au total, contre 447 chez AIOSEO sur le même site. * * ⇒ Le défaut n'était visible NULLE PART : l'option est juste, le sitemap répond * 200, le XML est valide, et les contrôles de paquet passent. Il fallait comparer * à un autre sitemap du même site pour le voir. * * ⭐ 99 PRÉSERVE L'INTENTION D'ORIGINE : on tire toujours sur `init`, donc toujours * avant `template_redirect` où Yoast et Rank Math servent les leurs. On perd * seulement la course contre un plugin qui s'accrocherait à `init` entre 6 et 99 — * cas non observé, et bien moins cher que perdre la boutique entière. * * ⚠ CE QUI FERAIT REVENIR À UNE PRIORITÉ BASSE : un plugin SEO concurrent qui * capterait l'URL avant nous. Le symptôme serait un sitemap qui n'est pas le nôtre * à cette adresse — pas un sitemap incomplet. Les deux défauts ne se ressemblent * pas, on ne les confondra pas. */ add_action( 'init', [ $this, 'serve_if_requested' ], 99 ); add_action( 'init', [ $this, 'add_rewrite' ] ); add_filter( 'query_vars', [ $this, 'add_query_var' ] ); add_action( 'template_redirect', [ $this, 'maybe_output' ] ); add_action( 'transition_post_status', [ $this, 'maybe_ping' ], 10, 3 ); /** * ⛔⛔ AJOUTÉ LE 30/08/2026 — L'EXTENSION GÉNÉRAIT UN PLAN DE SITE ET NE LE * DÉCLARAIT À PERSONNE. C'est le défaut le plus coûteux possible pour une * extension de sitemap : elle fait exactement son travail, le fichier répond 200, * le XML est valide — et aucun moteur ne sait qu'il existe. * * Mesuré sur un site en production (apsis.fr, 29/08) : le sitemap répondait 200 à * /aiforya-sitemap.xml, et robots.txt annonçait /wp-sitemap.xml qui rendait 404. * Google était donc envoyé dans le vide pendant que le bon fichier attendait à * côté. Il avait fallu soumettre l'adresse à la main dans la Search Console — * geste que personne ne fait sur un site qu'il n'administre pas lui-même. * * ⚠ CE QUE CE FILTRE NE FAIT PAS, ET C'EST DÉLIBÉRÉ : il ne retire PAS la ligne * `wp-sitemap.xml` de WordPress, même quand elle est morte. Notre extension ne * désactive pas le plan de site natif (aucun filtre `wp_sitemaps_enabled` ici) ; * si celui-ci rend 404 sur un site, la cause est ailleurs dans la pile, et une * extension publiée n'a pas à retirer en silence une déclaration qu'elle n'a pas * posée. On AJOUTE la nôtre — les deux lignes cohabitent, ce que le standard * robots.txt prévoit explicitement. */ add_filter( 'robots_txt', [ $this, 'declarer_dans_robots' ], 10, 2 ); } /** * Déclare le plan de site dans robots.txt — et SEULEMENT s'il a quelque chose à dire. * * ⭐ LA GARDE EST LE CŒUR DE CETTE MÉTHODE, PAS UN DÉTAIL. Annoncer une adresse morte * est PIRE que ne rien annoncer : un moteur qui suit une déclaration vers un 404 (ou * vers un index vide) n'apprend pas « il n'y a rien ici », il apprend « ce site * déclare n'importe quoi ». C'est le défaut exact qu'on vient de réparer, refait dans * l'autre sens. * * ⇒ On ne déclare que si les DEUX conditions qui décident du code HTTP réel sont * remplies. Ce sont les mêmes que `serve_if_requested()` puis `servir()` : * 1. `is_ready()` — sinon l'intercepteur rend 404 ; * 2. au moins un groupe — sinon l'index est un `` VIDE, document * parfaitement valide que Google lit comme « ce site n'a plus rien », et qui * désindexe. Cette seconde condition rend `build_index_xml()` null, donc 404. * * ⛔ ON NE FAIT PAS DE REQUÊTE HTTP VERS SOI-MÊME pour « vérifier le 200 ». C'était la * tentation, et elle est mauvaise ici : elle coûte un aller-retour réseau, elle peut * se bloquer sur un hébergement à un seul worker PHP (la requête attend sa propre * réponse), et elle mesure la même chose que ces deux lignes — en moins fiable, parce * qu'un pare-feu ou un cache peut répondre à notre place. * * @param string $output Contenu de robots.txt tel que construit jusqu'ici. * @param string $public Réglage « Visibilité » du site ('0' = on décourage les moteurs). * @return string */ public function declarer_dans_robots( $output, $public = '1' ): string { $output = (string) $output; // Le site demande à ne pas être indexé : ajouter un plan de site le contredirait. if ( '0' === (string) $public ) { return $output; } $settings = Aiforya_Smap_Settings::get_instance(); if ( ! $settings->is_ready() ) { return $output; } // Un index sans aucun groupe est un document vide : on ne l'annonce pas. if ( [] === $this->groupes() ) { return $output; } $url = home_url( '/aiforya-sitemap.xml' ); // Idempotence : un autre appel (ou un robots.txt physique repris) a pu la poser. if ( false !== strpos( $output, $url ) ) { return $output; } if ( '' !== $output && "\n" !== substr( $output, -1 ) ) { $output .= "\n"; } return $output . 'Sitemap: ' . esc_url_raw( $url ) . "\n"; } /** * Enregistre la règle de réécriture du plan de site. * * @return void */ public function add_rewrite(): void { // L'index — l'adresse historique. Elle ne rend plus un mais un // : c'est exactement ce que fait /wp-sitemap.xml, et un moteur // distingue les deux tout seul. Une adresse déjà soumise à la Search Console reste // donc valide, ce qui est la raison de ne PAS la déplacer. add_rewrite_rule( '^aiforya-sitemap\.xml$', 'index.php?' . self::QUERY_VAR . '=index', 'top' ); // Les pages. Le préfixe `posts-` / `taxonomies-` est repris de WordPress natif, et il // n'est pas décoratif : sans lui, un post type et une taxonomie portant le même nom // (cas réel — « product » est un post type, on peut enregistrer une taxonomie // « product ») produiraient la MÊME adresse, et l'une écraserait l'autre en silence. add_rewrite_rule( '^aiforya-sitemap-posts-([a-z0-9_\-]+)-([0-9]+)\.xml$', 'index.php?' . self::QUERY_VAR . '=posts&aiforya_smap_sous=$matches[1]&aiforya_smap_page=$matches[2]', 'top' ); add_rewrite_rule( '^aiforya-sitemap-taxonomies-([a-z0-9_\-]+)-([0-9]+)\.xml$', 'index.php?' . self::QUERY_VAR . '=taxonomies&aiforya_smap_sous=$matches[1]&aiforya_smap_page=$matches[2]', 'top' ); // Flush UNE fois, et seulement quand les règles ont réellement changé. Flusher à // chaque `init` coûterait une réécriture complète des permaliens à chaque page vue. if ( get_option( 'aiforya_smap_regles_version' ) !== self::VERSION_REGLES ) { flush_rewrite_rules( false ); update_option( 'aiforya_smap_regles_version', self::VERSION_REGLES ); } } /** * @param array $vars Variables de requête. * @return array */ public function add_query_var( array $vars ): array { $vars[] = self::QUERY_VAR; $vars[] = 'aiforya_smap_sous'; $vars[] = 'aiforya_smap_page'; return $vars; } /** * Intercepteur précoce (hook init, priorité 0) : sert le plan de site XML * directement quand l'URL demandée est « /aiforya-sitemap.xml », sans dépendre * de la règle de réécriture (qui peut être captée par un plugin SEO concurrent). * * @return void */ public function serve_if_requested(): void { $uri = isset( $_SERVER['REQUEST_URI'] ) ? esc_url_raw( wp_unslash( $_SERVER['REQUEST_URI'] ) ) : ''; if ( '' === $uri ) { return; } $path = (string) wp_parse_url( $uri, PHP_URL_PATH ); // L'index, puis les pages. L'intercepteur précoce doit reconnaître les MÊMES formes // que les règles de réécriture — sinon, sur un site où un plugin SEO capte l'URL, // l'index serait servi et les pages tomberaient en 404 : un index qui pointe vers des // fichiers absents, c'est pire qu'un sitemap tronqué. $type = ''; $sous = ''; $page = 1; if ( preg_match( '#/aiforya-sitemap\.xml/?$#', $path ) ) { $type = 'index'; } elseif ( preg_match( '#/aiforya-sitemap-(posts|taxonomies)-([a-z0-9_\-]+)-([0-9]+)\.xml/?$#', $path, $m ) ) { $type = $m[1]; $sous = $m[2]; $page = max( 1, (int) $m[3] ); } else { return; } $settings = Aiforya_Smap_Settings::get_instance(); if ( ! $settings->is_ready() ) { status_header( 404 ); nocache_headers(); exit; } $this->servir( $type, $sous, $page ); } /** * Écrit la réponse XML, ou un 404 si la page demandée n'existe pas. * * ⚠ LE 404 EST AUSSI IMPORTANT QUE LE XML. Une page hors bornes (page 9 d'un groupe qui * en compte 2) doit rendre 404, pas un vide : un urlset vide est un document * VALIDE, un moteur le prend pour « ce groupe ne contient plus rien » et désindexe. * Un 404 dit « cette adresse n'existe pas », ce qui est la vérité. * * @param string $type 'index' | 'posts' | 'taxonomies'. * @param string $sous Slug du post type ou de la taxonomie. * @param int $page Numéro de page, à partir de 1. * @return void */ private function servir( string $type, string $sous = '', int $page = 1 ): void { $xml = 'index' === $type ? $this->build_index_xml() : $this->build_urlset_xml( $type, $sous, $page ); nocache_headers(); if ( null === $xml ) { status_header( 404 ); exit; } if ( ! headers_sent() ) { status_header( 200 ); header( 'Content-Type: application/xml; charset=UTF-8' ); } echo $xml; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- flux XML : les URL sont passees par esc_url() a la construction, et echapper le document casserait le sitemap. exit; } /** * Sert le plan de site XML si la variable de requête est présente. * * @return void */ public function maybe_output(): void { $flag = get_query_var( self::QUERY_VAR ); if ( '' === $flag || null === $flag || false === $flag ) { return; } $settings = Aiforya_Smap_Settings::get_instance(); if ( ! $settings->is_ready() ) { status_header( 404 ); nocache_headers(); exit; } // `$flag` vaut désormais 'index', 'posts' ou 'taxonomies'. Les installations dont les // règles n'ont pas encore été rafraîchies peuvent encore envoyer l'ancien '1' : on le // traite comme l'index plutôt que de rendre un 404 pendant le battement. $type = (string) $flag; if ( '1' === $type || '' === $type ) { $type = 'index'; } $sous = (string) get_query_var( 'aiforya_smap_sous' ); $page = max( 1, (int) get_query_var( 'aiforya_smap_page' ) ); $this->servir( $type, $sous, $page ); } /** * La taille d'une page, bornée par le réglage `max_entries` sans jamais dépasser CAP. * * @return int */ private function taille_page(): int { $s = Aiforya_Smap_Settings::get_instance()->get(); $max = isset( $s['max_entries'] ) ? (int) $s['max_entries'] : self::PAR_PAGE; return max( 1, min( self::CAP, $max ) ); } /** * Les groupes du plan de site et leur pagination. * * Un groupe = un post type ou une taxonomie. Chacun est découpé en pages de * `taille_page()` adresses. Un groupe VIDE n'apparaît pas : un index qui pointerait vers * un fichier sans adresse ferait perdre un passage de robot pour rien. * * @return array */ public function groupes(): array { $s = Aiforya_Smap_Settings::get_instance()->get(); $taille = $this->taille_page(); $groupes = []; /* ⛔ CORRIGE LE 04/09/2026 — ON FILTRAIT SUR L EXISTENCE, PAS SUR LA VISIBILITE. * * `post_type_exists()` / `taxonomy_exists()` sont VRAIS pour un type ou une * taxonomie enregistres mais dont l archive ne repond pas. Le cas se produit * des qu un reglage change APRES l enregistrement du plan : les reglages * figent une liste, la generation la relit telle quelle, et sert des adresses * qui rendent 404. * * ⭐ LE CAS REEL, MESURE SUR LA PRODUCTION D UN CLIENT (apsis.fr, 04/09, releve * du foyer A) : WooCommerce enregistre TOUJOURS ses taxonomies `pa_*` ; * `attribute_public` ne pilote que `public`, `publicly_queryable` et `rewrite`. * Decocher « Activer les archives » laisse donc `taxonomy_exists()` a VRAI * pendant que l archive rend 404. L option du site portait 82 entrees dont * 77 `pa_*`, et le plan servait 51 sous-plans. * ⭐ CONTROLE POSITIF DEJA DISPONIBLE, rien a simuler : 7 attributs de ce site * ont deja `attribute_public = 0`, leurs 8 archives rendent 404 (8/8 au curl). * * ⚠ CE N EST PAS LE MEME GESTE QUE LE CORRECTIF 1.3.2. Celui-la change ce qu on * PROPOSE a l installation ; celui-ci change ce qu on SERT quand l etat du site * a change depuis. La promesse etait deja ecrite du cote qui OFFRE * (`available_taxonomies()` : « une taxonomie non publique n a pas d archive a * indexer ») — elle n etait pas tenue du cote qui GENERE. Regle 48. * * `is_post_type_viewable()` / `is_taxonomy_viewable()` sont les memes fonctions * que le plan de site NATIF de WordPress emploie. Disponibles depuis WP 5.1 ; * l extension exige deja 5.6. * * RE-MESURE : php backend/scripts/banc-visibilite-sitemap.php */ foreach ( ( is_array( $s['post_types'] ) ? $s['post_types'] : [] ) as $pt ) { if ( ! post_type_exists( $pt ) || ! is_post_type_viewable( $pt ) ) { continue; } $c = wp_count_posts( $pt ); $total = isset( $c->publish ) ? (int) $c->publish : 0; if ( $total < 1 ) { continue; } $groupes[] = [ 'type' => 'posts', 'sous' => $pt, 'total' => $total, 'pages' => (int) ceil( $total / $taille ) ]; } if ( ! empty( $s['include_taxonomies'] ) ) { $taxonomies = isset( $s['taxonomies'] ) && is_array( $s['taxonomies'] ) && ! empty( $s['taxonomies'] ) ? $s['taxonomies'] : [ 'category', 'post_tag' ]; /* Meme correctif que pour les types de contenu ci-dessus, et c est ICI que * le cas des `pa_*` de WooCommerce se produit. Voir l en-tete du bloc. */ $visible = static function ( $tx ): bool { return taxonomy_exists( $tx ) && is_taxonomy_viewable( $tx ); }; foreach ( array_filter( $taxonomies, $visible ) as $tx ) { // wp_count_terms() a change de signature en WP 5.6 : la forme a un seul // tableau est la moderne, l'ancienne prenait la taxonomie en premier. On // utilise la moderne — le plugin exige deja WP 5.6+ pour d'autres raisons. $total = (int) wp_count_terms( [ 'taxonomy' => $tx, 'hide_empty' => true ] ); if ( $total < 1 ) { continue; } $groupes[] = [ 'type' => 'taxonomies', 'sous' => $tx, 'total' => $total, 'pages' => (int) ceil( $total / $taille ) ]; } } return $groupes; } /** * L'adresse d'une page de plan de site. * * @param string $type 'posts' | 'taxonomies'. * @param string $sous Slug. * @param int $page Numéro de page. * @return string */ public function url_page( string $type, string $sous, int $page ): string { return home_url( '/aiforya-sitemap-' . $type . '-' . $sous . '-' . max( 1, $page ) . '.xml' ); } /** * L'INDEX — un qui liste toutes les pages. * * ⛔ REND `null` QUAND IL N'Y A AUCUN GROUPE, ET C'EST UN CHANGEMENT DU 30/08/2026. * Jusqu'ici, un site sans aucun contenu à publier recevait un `` VIDE * servi en **200**. Le paragraphe de `servir()` dit déjà pourquoi c'est le pire des * cas — « un urlset vide est un document VALIDE, un moteur le prend pour "ce groupe * ne contient plus rien" et désindexe » — mais la règle n'avait été appliquée qu'aux * PAGES, jamais à l'index lui-même. Le chemin de réparation existait déjà et n'était * simplement jamais emprunté : `servir()` sait rendre 404 sur un `null`. * * ⚠ Ce n'est pas un cas d'école : c'est exactement l'état d'un site fraîchement * installé, ou d'un site dont les réglages ne cochent aucun type de contenu publié. * * @return string|null `null` si aucun groupe — le routeur fera un 404. */ public function build_index_xml(): ?string { $groupes = $this->groupes(); if ( [] === $groupes ) { return null; } $out = '' . "\n"; $out .= '' . "\n"; foreach ( $groupes as $g ) { for ( $p = 1; $p <= $g['pages']; $p++ ) { $out .= "\t\n"; $out .= "\t\t" . htmlspecialchars( esc_url_raw( $this->url_page( $g['type'], $g['sous'], $p ) ), ENT_QUOTES, 'UTF-8' ) . "\n"; $out .= "\t\n"; } } $out .= '' . "\n"; return $out; } /** * UNE PAGE — un . Rend `null` si la page n'existe pas (le routeur fera un 404). * * @param string $type 'posts' | 'taxonomies'. * @param string $sous Slug. * @param int $page Numéro de page, à partir de 1. * @return string|null */ public function build_urlset_xml( string $type, string $sous, int $page ) { $taille = $this->taille_page(); $page = max( 1, $page ); // La page demandée doit exister DANS un groupe déclaré par l'index. Servir une page // d'un groupe non sélectionné laisserait une adresse vivante hors de l'index — // invisible au propriétaire du site, mais trouvable par un robot. $trouve = null; foreach ( $this->groupes() as $g ) { if ( $g['type'] === $type && $g['sous'] === $sous ) { $trouve = $g; break; } } if ( null === $trouve || $page > $trouve['pages'] ) { return null; } $entries = []; // ⛔ L'ACCUEIL ÉTAIT PUBLIÉ DEUX FOIS QUAND LE SITE A UNE PAGE D'ACCUEIL STATIQUE. // Mesuré le 01/09/2026 sur trois sites en production : webproformation.fr 21 // pour 20 uniques, webprocreation.fr 18/17, webproconseil.fr 18/17 — toujours la // home. La signature ne laissait aucun doute : l'entrée en double était SANS // (celle ajoutée ici à la main) face à celle AVEC (la même page, sortie // par la WP_Query ci-dessous sur post_type=page). // // Le bloc ci-dessous disait déjà « le placer partout le dupliquerait » — il avait // raison, et il ne voyait pas que la duplication ne venait pas d'ici mais de la // requête. `page_on_front` n'était lu NULLE PART dans l'extension. // // ⚠ PORTÉE DÉCLARÉE (règle 48) : ceci ne traite que la page d'accueil STATIQUE // (show_on_front = 'page'). Avec show_on_front = 'posts', home_url('/') est l'index // du blog, il n'est le permalien d'aucun contenu, et il n'y a rien à dédupliquer. $front_id = ( 'page' === get_option( 'show_on_front' ) ) ? (int) get_option( 'page_on_front' ) : 0; // L'accueil est servi UNE FOIS, en tête de la toute première page du premier groupe. // Le placer partout le dupliquerait ; ne le placer nulle part le perdrait. $premiers = $this->groupes(); if ( ! empty( $premiers ) && 1 === $page && $premiers[0]['type'] === $type && $premiers[0]['sous'] === $sous ) { // Et tant qu'à ne l'écrire qu'une fois, autant lui donner sa vraie date : la // version d'avant rendait la home SANS lastmod alors que l'information existait. $lastmod_accueil = ''; if ( $front_id > 0 ) { $front_post = get_post( $front_id ); if ( $front_post instanceof WP_Post ) { $lastmod_accueil = mysql2date( 'c', (string) $front_post->post_modified_gmt, false ); } } $entries[] = [ 'loc' => home_url( '/' ), 'lastmod' => $lastmod_accueil ]; } if ( 'posts' === $type ) { $q = new WP_Query( [ 'post_type' => $sous, 'post_status' => 'publish', 'posts_per_page' => $taille, 'paged' => $page, 'no_found_rows' => true, 'ignore_sticky_posts' => true, 'orderby' => 'ID', 'order' => 'ASC', 'update_post_meta_cache' => false, 'update_post_term_cache' => false, ] ); foreach ( $q->posts as $post ) { // La page d'accueil statique est DÉJÀ publiée plus haut, une seule fois, // en tête du premier groupe. La sauter ici est ce qui empêche le doublon — // et la sauter par son ID plutôt que par comparaison d'URL évite de dépendre // de la barre oblique finale, du protocole ou du sous-domaine. if ( $front_id > 0 && (int) $post->ID === $front_id ) { continue; } $link = get_permalink( $post ); if ( ! $link ) { continue; } $entries[] = [ 'loc' => $link, 'lastmod' => mysql2date( 'c', (string) $post->post_modified_gmt, false ), ]; } } else { $terms = get_terms( [ 'taxonomy' => $sous, 'hide_empty' => true, 'number' => $taille, 'offset' => ( $page - 1 ) * $taille, 'orderby' => 'term_id', 'order' => 'ASC', ] ); if ( is_array( $terms ) ) { foreach ( $terms as $term ) { if ( ! ( $term instanceof WP_Term ) ) { continue; } $link = get_term_link( $term ); if ( is_wp_error( $link ) || ! is_string( $link ) ) { continue; } $entries[] = [ 'loc' => $link, 'lastmod' => '' ]; } } } return $this->rendre_urlset( $entries ); } /** * ⚠ L'ORDRE DE TRI EST « ID ASC », ET CE N'EST PAS UN DÉTAIL DE STYLE. * * L'ancien code triait par date de modification décroissante. Sur un sitemap PAGINÉ, * c'est un défaut : modifier un vieil article le fait remonter en page 1 et décale TOUT * le reste d'un cran — chaque page change de contenu à chaque édition, et les robots * re-téléchargent l'ensemble pour rien. Un ordre stable (ID croissant) garde chaque * adresse sur sa page tant qu'aucune n'est ajoutée ou retirée. * * @param array $entries Entrées. * @return string */ private function rendre_urlset( array $entries ): string { $out = '' . "\n"; $out .= '' . "\n"; foreach ( $entries as $entry ) { $loc = isset( $entry['loc'] ) ? (string) $entry['loc'] : ''; if ( '' === $loc ) { continue; } $out .= "\t\n"; $out .= "\t\t" . htmlspecialchars( esc_url_raw( $loc ), ENT_QUOTES, 'UTF-8' ) . "\n"; if ( ! empty( $entry['lastmod'] ) ) { $out .= "\t\t" . htmlspecialchars( (string) $entry['lastmod'], ENT_QUOTES, 'UTF-8' ) . "\n"; } $out .= "\t\n"; } $out .= '' . "\n"; return $out; } /** * Décomptes par type de contenu inclus (pour l'onglet Aperçu). * * @return array */ public function counts_by_post_type(): array { $settings = Aiforya_Smap_Settings::get_instance(); $s = $settings->get(); $post_types = is_array( $s['post_types'] ) ? array_values( $s['post_types'] ) : []; $out = []; foreach ( $post_types as $pt ) { $counts = wp_count_posts( $pt ); $out[ $pt ] = isset( $counts->publish ) ? (int) $counts->publish : 0; } return $out; } /** * Notifie les moteurs de recherche à la publication d'un contenu (optionnel). * * Comportement standard de « ping » d'un plan de site : lorsqu'un contenu * passe en « publié », l'adresse du plan de site est signalée à Google et * Bing. Désactivé par défaut. * * @param string $new_status Nouveau statut. * @param string $old_status Ancien statut. * @param \WP_Post $post Publication. * @return void */ public function maybe_ping( string $new_status, string $old_status, $post ): void { if ( 'publish' !== $new_status || 'publish' === $old_status ) { return; } $settings = Aiforya_Smap_Settings::get_instance(); $s = $settings->get(); if ( empty( $s['enabled'] ) || empty( $s['ping_on_publish'] ) ) { return; } if ( ! ( $post instanceof WP_Post ) ) { return; } $post_types = is_array( $s['post_types'] ) ? $s['post_types'] : []; if ( ! in_array( $post->post_type, $post_types, true ) ) { return; } $sitemap_url = rawurlencode( home_url( '/aiforya-sitemap.xml' ) ); $endpoints = [ 'https://www.google.com/ping?sitemap=' . $sitemap_url, 'https://www.bing.com/ping?sitemap=' . $sitemap_url, ]; foreach ( $endpoints as $endpoint ) { wp_remote_get( $endpoint, [ 'timeout' => 5, 'blocking' => false, 'sslverify' => true, ] ); } } } endif;