J'ai fait des recherches assez approfondies sur la façon d'utiliser pre_get_postssur les vraies pages et les premières pages statiques, et il semble qu'il n'y ait pas de méthode infaillible.
La meilleure option que j'ai trouvée à ce jour provient d'un article rédigé par @birgire sur Stackoverflow . Je l'ai réécrit dans une classe de démonstration et j'ai rendu le code un peu plus dynamique
class PreGeTPostsForPages
{
/**
* @var string|int $pageID
* @access protected
* @since 1.0.0
*/
protected $pageID;
/**
* @var bool $injectPageIntoLoop
* @access protected
* @since 1.0.0
*/
protected $injectPageIntoLoop;
/**
* @var array $args
* @access protected
* @since 1.0.0
*/
protected $args;
/**
* @var int $validatedPageID
* @access protected
* @since 1.0.0
*/
protected $validatedPageID = 0;
/**
* Constructor
*
* @param string|int $pageID = NULL
* @param bool $injectPageIntoLoop = false
* @param array| $args = []
* @since 1.0.0
*/
public function __construct(
$pageID = NULL,
$injectPageIntoLoop = true,
$args = []
) {
$this->pageID = $pageID;
$this->injectPageIntoLoop = $injectPageIntoLoop;
$this->args = $args;
}
/**
* Private method validatePageID()
*
* Validates the page ID passed
*
* @since 1.0.0
*/
private function validatePageID()
{
$validatedPageID = filter_var( $this->pageID, FILTER_VALIDATE_INT );
$this->validatedPageID = $validatedPageID;
}
/**
* Public method init()
*
* This method is used to initialize our pre_get_posts action
*
* @since 1.0.0
*/
public function init()
{
// Load the correct actions according to the value of $this->keepPageIntegrity
add_action( 'pre_get_posts', [$this, 'preGetPosts'] );
}
/**
* Protected method pageObject()
*
* Gets the queried object to use that as page object
*
* @since 1.0.0
*/
protected function pageObject()
{
global $wp_the_query;
return $wp_the_query->get_queried_object();
}
/**
* Public method preGetPosts()
*
* This is our call back method for the pre_get_posts action.
*
* The pre_get_posts action will only be used if the page integrity is
* not an issue, which means that the page will be altered to work like a
* normal archive page. Here you have the option to inject the page object as
* first post through the_posts filter when $this->injectPageIntoLoop === true
*
* @since 1.0.0
*/
public function preGetPosts( \WP_Query $q )
{
// Make sure that we are on the main query and the desired page
if ( is_admin() // Only run this on the front end
|| !$q->is_main_query() // Only target the main query
|| !is_page( $this->validatedPageID ) // Run this only on the page specified
)
return;
// Remove the filter to avoid infinte loops
remove_filter( current_filter(), [$this, __METHOD__] );
// METHODS:
$this->validatePageID();
$this->pageObject();
$queryArgs = $this->args;
// Set default arguments which cannot be changed
$queryArgs['pagename'] = NULL;
// We have reached this point, lets do what we need to do
foreach ( $queryArgs as $key=>$value )
$q->set(
filter_var( $key, FILTER_SANITIZE_STRING ),
$value // Let WP_Query handle the sanitation of the values accordingly
);
// Set $q->is_singular to 0 to get pagination to work
$q->is_singular = false;
// FILTERS:
add_filter( 'the_posts', [$this, 'addPageAsPost'], PHP_INT_MAX );
add_filter( 'template_include', [$this, 'templateInclude'], PHP_INT_MAX );
}
/**
* Public callback method hooked to 'the_posts' filter
* This will inject the queried object into the array of posts
* if $this->injectPageIntoLoop === true
*
* @since 1.0.0
*/
public function addPageAsPost( $posts )
{
// Inject the page object as a post if $this->injectPageIntoLoop == true
if ( true === $this->injectPageIntoLoop )
return array_merge( [$this->pageObject()], $posts );
return $posts;
}
/**
* Public call back method templateInclude() for the template_include filter
*
* @since 1.0.0
*/
public function templateInclude( $template )
{
// Remove the filter to avoid infinte loops
remove_filter( current_filter(), [$this, __METHOD__] );
// Get the page template saved in db
$pageTemplate = get_post_meta(
$this->validatedPageID,
'_wp_page_template',
true
);
// Make sure the template exists before we load it, but only if $template is not 'default'
if ( 'default' !== $pageTemplate ) {
$locateTemplate = locate_template( $pageTemplate );
if ( $locateTemplate )
return $template = $locateTemplate;
}
/**
* If $template returned 'default', or the template is not located for some reason,
* we need to get and load the template according to template hierarchy
*
* @uses get_page_template()
*/
return $template = get_page_template();
}
}
$init = new PreGeTPostsForPages(
251, // Page ID
false,
[
'posts_per_page' => 3,
'post_type' => 'post'
]
);
$init->init();Cela fonctionne bien et page comme prévu en utilisant ma propre fonction de pagination .
PROBLÈMES:
En raison de la fonction, je perds l'intégrité de la page qui remplit d'autres fonctions en fonction de l'objet de page stocké dans $post. $postavant que la boucle ne soit définie sur le premier post de la boucle et $postsur le dernier post de la boucle après la boucle, ce qui est attendu. Ce dont j'ai besoin, c'est qu'il $postsoit défini sur l'objet de page actuel, c'est-à-dire l'objet interrogé.
En outre, $wp_the_query->postet $wp_query->postdétient le premier message de la boucle et non l'objet interrogé comme sur une page normale
J'utilise ce qui suit (en dehors de ma classe ) pour vérifier mes globales avant et après la boucle
add_action( 'wp_head', 'printGlobals' );
add_action( 'wp_footer', 'printGlobals' );
function printGlobals()
{
$global_test = 'QUERIED OBJECT: ' . $GLOBALS['wp_the_query']->queried_object_id . '</br>';
$global_test .= 'WP_THE_QUERY: ' . $GLOBALS['wp_the_query']->post->ID . '</br>';
$global_test .= 'WP_QUERY: ' . $GLOBALS['wp_query']->post->ID . '</br>';
$global_test .= 'POST: ' . $GLOBALS['post']->ID . '</br>';
$global_test .= 'FOUND_POSTS: ' . $GLOBALS['wp_query']->found_posts . '</br>';
$global_test .= 'MAX_NUM_PAGES: ' . $GLOBALS['wp_query']->max_num_pages . '</br>';
?><pre><?php var_dump( $global_test ); ?></pre><?php
}AVANT LA BOUCLE:
Avant la boucle, le problème est partiellement résolu en définissant la valeur $injectPageIntoLooptrue qui injecte l'objet page en tant que première page de la boucle. C'est très utile si vous devez afficher les informations de la page avant les messages demandés, mais si vous ne le souhaitez pas, vous êtes foutu.
Je peux résoudre le problème avant la boucle en piratant directement les globaux, ce que je n'aime pas vraiment. Je connecte la méthode suivante à l' wpintérieur de ma preGetPostsméthode
public function wp()
{
$page = get_post( $this->pageID );
$GLOBALS['wp_the_query']->post = $page;
$GLOBALS['wp_query'] = $GLOBALS['wp_the_query'];
$GLOBALS['post'] = $page;
}et preGetPostsméthode intérieure
add_action( 'wp', [$this, 'wp'] );De là, $wp_the_query->post, $wp_query->postet $posttoutes les cales de l'objet de la page.
APRÈS LA BOUCLE
C'est là que se situe mon gros problème, après la boucle. Après avoir piraté les globaux à travers le wpcrochet et la méthode,
$wp_the_query->postet$wp_query->postest remis au premier poste de la boucle, comme prévu$postest défini sur le dernier message de la boucle.
Ce dont j'ai besoin, c'est que les trois soient replacés sur l'objet interrogé / l'objet de page actuel.
J'ai essayé d'accrocher la wpméthode à l' loop_endaction, ce qui ne fonctionne pas. Accrocher la wpméthode à l' get_sidebaraction fonctionne, mais il est trop tard.
add_action( 'get_sidebar', [$this, 'wp'] );L'exécution printGlobals()directe après la boucle dans le modèle confirme que as $wp_the_query->postet $wp_query->postsont toujours définis sur le premier message et $postsur le dernier message.
Je peux ajouter manuellement le code à l'intérieur de la wpméthode après la boucle à l'intérieur du modèle, mais l'idée n'est pas de modifier directement les fichiers de modèle car la classe devrait être transférable dans un plugin entre les thèmes.
Y at - il bonne façon de résoudre ce problème où une exécution pre_get_postssur une vraie page et la page d'accueil statique et toujours garder l'intégrité $wp_the_query->post, $wp_query->postet $post( ayant ceux à l'objet ensemble interrogé ) avant et après la boucle.
ÉDITER
Il semble y avoir confusion sur ce dont j'ai besoin et pourquoi j'en ai besoin
Ce dont j'ai besoin
Je dois conserver les valeurs de $wp_the_query->post, $wp_query->postet à $posttravers le modèle quel que soit, et que la valeur doit être l'objet interrogé. À ce stade, avec le code que j'ai publié, les valeurs de ces trois variables ne contiennent pas l'objet de page, mais plutôt les objets de messages dans la boucle. J'espère que c'est assez clair.
J'ai publié du code que vous pouvez utiliser pour tester ces variables
Pourquoi j'en ai besoin
J'ai besoin d'un moyen fiable pour ajouter des publications via des pre_get_postsmodèles de page et des premières pages statiques sans modifier la fonctionnalité de la page complète. À ce stade, en l'état du code en question, il casse ma fonctionnalité de fil d'Ariane et la fonctionnalité de page associée après la boucle en raison de $postlaquelle contient le "mauvais" objet de publication.
Surtout, je ne veux pas modifier directement les modèles de page. Je veux être en mesure d'ajouter des messages à un modèle de page sans AUCUNE modification du modèle
