add_action sur parse_request

Suite à la migration du forum, chaque utilisateur devra lancer une procédure de réinitialisation du mot de passe pour pouvoir se connecter. Merci !

  • Statut : non résolu
3 sujets de 1 à 3 (sur un total de 3)
  • Auteur
    Articles
  • #497487

    willy bahuaud
    Membre
    Initié WordPress
    1 contributions

    Bonjour,

    Ma configuration WP actuelle
    – Version de WordPress : 3.2
    – Adresse du site : http://ajax.wuiwui.net

    Problème(s) rencontré(s) :

    Voilà, je travail actuellement sur un thème Full ajax et la possibilité de le rendre indexable dans google.
    Je ne sais pas si vous connaissez l’astuce du _escaped_fragment_ mais ça marche très bien sur ce site.

    Mon souci vient pluôt de la façon de coder mon truc : directement dans le cœur de wordpress, dans le fichier class-wp.php, dans la fonction parse_request de la class WP, j’ai du changer une ligne… c’est crade…:fouet:

    J’ai modifié

    $req_uri =$_SERVER[‘REQUEST_URI’];

    en

    $req_uri = str_replace(‘?_escaped_fragment_=’, »,$_SERVER[‘REQUEST_URI’]);

    je sais, c’est hyper crade, mais c’est le seul moyen que j’ai trouvé pour que google accède à mon contenu.
    J’essaye de faire cette modification directement à partir du fichier fonctions.php de mon thème (avec un add_filter/add_action) mais je n’y arrive pas vraiment… ça me génère une erreur.

    J’ai recopier l’intégralité de la fonction parse request, ajouté un add_action, et modifié la ligne qui m’intéresse (mais vu que c’est un objet, le callbackest un array):

    add_action(« parse_request », array(&$this, ‘my_parse_request’));
    	function my_parse_request($extra_query_vars =  »){
    		global $wp_rewrite;
    
    		$this->query_vars = array();
    		$post_type_query_vars = array();
    
    		if ( is_array($extra_query_vars) )
    			$this->extra_query_vars = & $extra_query_vars;
    		else if (! empty($extra_query_vars))
    			parse_str($extra_query_vars, $this->extra_query_vars);
    
    		// Process PATH_INFO, REQUEST_URI, and 404 for permalinks.
    
    		// Fetch the rewrite rules.
    		$rewrite = $wp_rewrite->wp_rewrite_rules();
    
    		if ( ! empty($rewrite) ) {
    			// If we match a rewrite rule, this will be cleared.
    			$error = ‘404’;
    			$this->did_permalink = true;
    
    			if ( isset($_SERVER[‘PATH_INFO’]) )
    				$pathinfo = $_SERVER[‘PATH_INFO’];
    			else
    				$pathinfo =  »;
    			$pathinfo_array = explode(‘?’, $pathinfo);
    			$pathinfo = str_replace(« % », « %25″, $pathinfo_array[0]);
    			$req_uri = str_replace(‘?_escaped_fragment_=’, »,$_SERVER[‘REQUEST_URI’]); //iciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
    			$req_uri_array = explode(‘?’, $req_uri);
    			$req_uri = $req_uri_array[0];
    			$self = $_SERVER[‘PHP_SELF’];
    			$home_path = parse_url(home_url());
    			if ( isset($home_path[‘path’]) )
    				$home_path = $home_path[‘path’];
    			else
    				$home_path =  »;
    			$home_path = trim($home_path, ‘/’);
    
    			// Trim path info from the end and the leading home path from the
    			// front.  For path info requests, this leaves us with the requesting
    			// filename, if any.  For 404 requests, this leaves us with the
    			// requested permalink.
    			$req_uri = str_replace($pathinfo,  », $req_uri);
    			$req_uri = trim($req_uri, ‘/’);
    			$req_uri = preg_replace(« |^$home_path| »,  », $req_uri);
    			$req_uri = trim($req_uri, ‘/’);
    			$pathinfo = trim($pathinfo, ‘/’);
    			$pathinfo = preg_replace(« |^$home_path| »,  », $pathinfo);
    			$pathinfo = trim($pathinfo, ‘/’);
    			$self = trim($self, ‘/’);
    			$self = preg_replace(« |^$home_path| »,  », $self);
    			$self = trim($self, ‘/’);
    
    			// The requested permalink is in $pathinfo for path info requests and
    			//  $req_uri for other requests.
    			if ( ! empty($pathinfo) && !preg_match(‘|^.*’ . $wp_rewrite->index . ‘$|’, $pathinfo) ) {
    				$request = $pathinfo;
    			} else {
    				// If the request uri is the index, blank it out so that we don’t try to match it against a rule.
    				if ( $req_uri == $wp_rewrite->index )
    					$req_uri =  »;
    				$request = $req_uri;
    			}
    
    			$this->request = $request;
    
    			// Look for matches.
    			$request_match = $request;
    			foreach ( (array) $rewrite as $match => $query) {
    				// Don’t try to match against AtomPub calls
    				if ( $req_uri == ‘wp-app.php’ )
    					break;
    
    				// If the requesting file is the anchor of the match, prepend it
    				// to the path info.
    				if ( (! empty($req_uri)) && (strpos($match, $req_uri) === 0) && ($req_uri != $request) )
    					$request_match = $req_uri . ‘/’ . $request;
    
    				if ( preg_match(« #^$match# », $request_match, $matches) ||
    					preg_match(« #^$match# », urldecode($request_match), $matches) ) {
    					// Got a match.
    					$this->matched_rule = $match;
    
    					// Trim the query of everything up to the ‘?’.
    					$query = preg_replace(« !^.+?! »,  », $query);
    
    					// Substitute the substring matches into the query.
    					$query = addslashes(WP_MatchesMapRegex::apply($query, $matches));
    
    					$this->matched_query = $query;
    
    					// Parse the query.
    					parse_str($query, $perma_query_vars);
    
    					// If we’re processing a 404 request, clear the error var
    					// since we found something.
    					if ( isset($_GET[‘error’]) )
    						unset($_GET[‘error’]);
    
    					if ( isset($error) )
    						unset($error);
    
    					break;
    				}
    			}
    
    			// If req_uri is empty or if it is a request for ourself, unset error.
    			if ( empty($request) || $req_uri == $self || strpos($_SERVER[‘PHP_SELF’], ‘wp-admin/’) !== false ) {
    				if ( isset($_GET[‘error’]) )
    					unset($_GET[‘error’]);
    
    				if ( isset($error) )
    					unset($error);
    
    				if ( isset($perma_query_vars) && strpos($_SERVER[‘PHP_SELF’], ‘wp-admin/’) !== false )
    					unset($perma_query_vars);
    
    				$this->did_permalink = false;
    			}
    		}
    
    		$this->public_query_vars = apply_filters(‘query_vars’, $this->public_query_vars);
    
    		foreach ( $GLOBALS[‘wp_post_types’] as $post_type => $t )
    			if ( $t->query_var )
    				$post_type_query_vars[$t->query_var] = $post_type;
    
    		foreach ( $this->public_query_vars as $wpvar ) {
    			if ( isset( $this->extra_query_vars[$wpvar] ) )
    				$this->query_vars[$wpvar] = $this->extra_query_vars[$wpvar];
    			elseif ( isset( $_POST[$wpvar] ) )
    				$this->query_vars[$wpvar] = $_POST[$wpvar];
    			elseif ( isset( $_GET[$wpvar] ) )
    				$this->query_vars[$wpvar] = $_GET[$wpvar];
    			elseif ( isset( $perma_query_vars[$wpvar] ) )
    				$this->query_vars[$wpvar] = $perma_query_vars[$wpvar];
    
    			if ( !empty( $this->query_vars[$wpvar] ) ) {
    				if ( ! is_array( $this->query_vars[$wpvar] ) ) {
    					$this->query_vars[$wpvar] = (string) $this->query_vars[$wpvar];
    				} else {
    					foreach ( $this->query_vars[$wpvar] as $vkey => $v ) {
    						if ( !is_object( $v ) ) {
    							$this->query_vars[$wpvar][$vkey] = (string) $v;
    						}
    					}
    				}
    
    				if ( isset($post_type_query_vars[$wpvar] ) ) {
    					$this->query_vars[‘post_type’] = $post_type_query_vars[$wpvar];
    					$this->query_vars[‘name’] = $this->query_vars[$wpvar];
    				}
    			}
    		}
    
    		// Convert urldecoded spaces back into +
    		foreach ( $GLOBALS[‘wp_taxonomies’] as $taxonomy => $t )
    			if ( $t->query_var && isset( $this->query_vars[$t->query_var] ) )
    				$this->query_vars[$t->query_var] = str_replace( ‘ ‘, ‘+’, $this->query_vars[$t->query_var] );
    
    		// Limit publicly queried post_types to those that are publicly_queryable
    		if ( isset( $this->query_vars[‘post_type’]) ) {
    			$queryable_post_types = get_post_types( array(‘publicly_queryable’ => true) );
    			if ( ! is_array( $this->query_vars[‘post_type’] ) ) {
    				if ( ! in_array( $this->query_vars[‘post_type’], $queryable_post_types ) )
    					unset( $this->query_vars[‘post_type’] );
    			} else {
    				$this->query_vars[‘post_type’] = array_intersect( $this->query_vars[‘post_type’], $queryable_post_types );
    			}
    		}
    
    		foreach ( (array) $this->private_query_vars as $var) {
    			if ( isset($this->extra_query_vars[$var]) )
    				$this->query_vars[$var] = $this->extra_query_vars[$var];
    		}
    
    		if ( isset($error) )
    			$this->query_vars[‘error’] = $error;
    
    		$this->query_vars = apply_filters(‘request’, $this->query_vars);
    
    		do_action_ref_array(‘parse_request’, array(&$this));
    	}

    Et voilà avec ça, j’obtient ce que je veux, mais avec un joli « Warning: call_user_func_array() [function.call-user-func-array]: First argument is expected to be a valid callback, ‘Array’ was given in /web/wuiwui1/ajax/wp-includes/plugin.php on line 486 » en plus…

    Savez-vous comment je pourrai faire plus propre ?? Sans obtenir le warning, au moins ?:(

    Merci d’avance !!

    PS: dès que ça marche complètement j’en ferait un tutoriel pour expliquer comment ça marche et comment rendre son contenu ajax indexable par google (sans utiliser de headless browser) :D

    #781950

    SeoMix
    Membre
    Padawan WordPress
    52 contributions

    Essaye avec :

    add_action(« parse_request », ‘my_parse_request’);

    (sur une idée de BoiteaWeb)

    #781951

    rouge13
    Membre
    Initié WordPress
    5 contributions
    add_action(« parse_request », ‘my_parse_request’);

    C’est ce que j’ai essayé en premier, car c’est le plus logique. Mais non… j’obtient ça :

    Fatal error: Using $this when not in object context in /xxx/xxx/xxx/wp-content/themes/themeajax/functions.php on line 41

    Car la fonction d’origine est dans la class WP, cette fonction fait donc appel à un objet… d’où le $this.

    😕

3 sujets de 1 à 3 (sur un total de 3)
  • Le forum ‘Utilisation spécifique de WordPress’ est fermé à de nouveaux sujets et réponses.