Onde, Quando e Como Regular Adequadamente as Regras de Regravação Dentro do Escopo de um Plugin?

9

Estou com um problema estranho, mas as regras de regravação não funcionam corretamente.

Eu tentei usar flush_rewrite_rules(); e flush_rewrite_rules(true); .

Eu também tentei globalizar $wp_rewrite usando $wp_rewrite->flush_rules(); e $wp_rewrite->flush_rules(true);

Nenhuma das duas parece estar liberando as regras de reescrita corretamente. Essas chamadas estão realmente liberando as regras de reescrita quando chamadas. Como eu sei disso? Usando a solução para depuração de regra de regravação .

Atualmente, eu reescrevi as regras liberadas na ativação do plug-in e na desativação do plug-in. Não há problemas lá.

Eu tenho uma página de configurações de administração do plug-in para os usuários configurarem o plug-in. Algumas das configurações ajustam a estrutura do link permanente, portanto, as regras de regravação precisam ser liberadas na página de configurações de administração do plug-in "Salvar configurações". (Usa o padrão update_option(); ) para salvar as configurações.

Gostaria de observar que, dependendo das configurações especificadas, os tipos de postagem personalizados são criados para corresponder às configurações especificadas pelo usuário. Portanto, as regras de regravação devem ser liberadas imediatamente após as configurações serem salvas. É aqui que as coisas não estão funcionando adequadamente.

A solução de link acima para depurar as regras de reescrita fornecidas por @toscho está exibindo que está descarregando toneladas de reescrita regras. No entanto, ao visitar o tipo singular de postagem personalizada, ou até o arquivo de tipo de postagem personalizado, cada um retornará como erros 404.

O tipo de postagem personalizada é registrado corretamente e de forma adequada. Eu sei com certeza que não é o problema.

Imediatamente após salvar as configurações da página de administração do plug-in. Os tipos de postagem personalizados são criados, a estrutura de permalink é ajustada e todas as regras de regravação são tentadas a serem liberadas.

Os tipos de postagem personalizados são carregados sempre e carregados em init como normal.

Por alguma razão, as regras de reescrita não são liberadas corretamente, porque, como eu disse antes, visitando seções singulares ou de arquivo do tipo de postagem personalizada return 404 errors.

Agora, a parte estranha, se tudo o que eu faço é simplesmente visitar a página de configurações de permalinks de administração e depois voltar para o front-end para ver seções singulares ou de arquivamento do tipo de postagem personalizado, elas funcionam magicamente conforme o esperado.

O que essa administração permalinks na página de configurações faz que eu não estou fazendo isso permite que as regras de reescrita sejam liberadas apropriadamente e as minhas não?

Quero dizer, como uma solução temporária, estou redirecionando o usuário para a página de configurações permalinks de administração depois de salvar a página de configurações de administração do plug-in, mas essa não é uma solução ideal. Eu prefiro que as regras de reescrita sejam liberadas corretamente no código do meu plugin.

Existe algum ponto no WordPress em que liberar as regras de reescrita simplesmente não elimina TODAS as regras?

admin_menu - A página de configurações de plugins é adicionada à administração do WordPress.

add_options_page() - A página de configurações de plugins é adicionada no menu Configurações.

A página Configurações é renderizada no retorno de chamada de add_options_page() . Este também é o local em que $_POST é processado para atualizar as configurações do plug-in e liberar as regras de reescrita.

Como essa já é uma pergunta longa, eu estaria disposto a fornecer blocos de código (se ajudar) em um link externo que ajudasse a produzir uma resposta válida.

    
por Michael Ecklund 15.11.2013 / 18:20

6 respostas

4

O melhor lugar para liberar as regras de reescrita é a ativação / desativação do plugin.

function myplugin_activate() {
    // register taxonomies/post types here
    flush_rewrite_rules();
}

register_activation_hook( __FILE__, 'myplugin_activate' );

function myplugin_deactivate() {
    flush_rewrite_rules();
}
register_deactivation_hook( __FILE__, 'myplugin_deactivate' );

Veja o artigo do códice

Desculpas antecipadas, não cheguei até a sua pergunta, então isso é um pouco como uma resposta do cortador de biscoitos.

    
por helgatheviking 15.11.2013 / 18:37
4

Difícil dizer o que está errado, sem ver seu código. Mas depois de salvar algumas configurações, é prático conectar em admin_init como mostrado abaixo para liberar suas regras de reescrita.

Código:

add_action('admin_init', 'wpse_123401_plugin_settings_flush_rewrite');
function wpse_123401_plugin_settings_flush_rewrite() {
    if ( get_option('plugin_settings_have_changed') == true ) {
        flush_rewrite_rules();
        update_option('plugin_settings_have_changed', false);
    }
}


Você tem que definir a opção em algum lugar na sua página de configurações ou para ser exato em algum lugar no processo de salvar as configurações. Fazê-lo sem a opção é ruim, porque você não quer liberar as regras todas as vezes.


Nota: não testado

    
por Nicolai 15.11.2013 / 19:47
3

Eu tinha um arquivo de classe post types que era responsável por ler as configurações das opções do plug-in e criar os tipos de postagem personalizados necessários com base nas configurações especificadas pelo usuário.

Este arquivo de classe de tipos de postagem foi carregado no gancho init .

Eu percebi que tudo o que eu precisaria fazer era atualizar as configurações do plug-in e liberar as regras de reconfiguração. Desde que a classe post types já foi carregada com base nas configurações do plugin. Mas com as páginas de administração, elas são carregadas APÓS o gancho init .

Os tipos de postagem nunca foram realmente registrados, porque as configurações ainda não estavam definidas. A classe de registro de tipos de postagem foi encerrada prematuramente sem nenhum tipo de registro registrado.

A solução foi:

  1. Atualize as configurações do plug-in.
  2. Carregue o arquivo de classe de tipos de postagem SOMENTE uma vez aqui para que o novo regras de reescrita são criadas.
  3. Liberar as regras de reescrita.

(Anteriormente ... o passo 2 estava faltando - Como mencionado acima ...)

A partir de agora, os tipos de postagem serão carregados no gancho init e terão as configurações já especificadas, permitindo que tipos de postagem sejam criados e combinados com regras de reescrita apropriadas.

Por qualquer razão, eu tive que adicionar uma chamada de JavaScript para redirecionar para a página atual, depois de realizar os três passos acima.

Também precisei adicionar uma chamada para flush_rewrite_rules(); na página de configurações de administração do plug-in.

Então, para garantir que tudo seja esvaziado ...

Passo 1) Navegue até a página de configurações de administração do plugin. - Flush inicial.

Passo 2) Atualize as configurações do plugin. - Segundo flush.

Etapa 3) A página redireciona para a página de configurações do plug-in. Causando o ... Terceiro e final flush (o mesmo que o flush inicial - Feito automaticamente quando a página de configurações do plugin é visitada)

Não estou dizendo que essa é uma solução prática, mas funcionou para mim. Questão muito estranha e muito provavelmente tem a ver com a minha infra-estrutura de codificação.

    
por Michael Ecklund 15.11.2013 / 20:38
1

@ tazo-todua isso funcionou para mim também ao usar multisite.

add_action( 'wpmu_new_blog', 'set_my_permalink_structure', 11, 2 );

function set_my_permalink_structure( $blog_id ) {

    switch_to_blog( $blog_id );

    global $wp_rewrite;
    $wp_rewrite->set_permalink_structure( '/%postname%/' );
    $wp_rewrite->flush_rules();
    $wp_rewrite->init();

    restore_current_blog();
}
    
por stillatmylinux 11.11.2016 / 22:30
0

MINHA SOLUÇÃO encontrada FOI:

global $wp_rewrite; $wp_rewrite->flush_rules(); $wp_rewrite->init();
    
por T.Todua 20.04.2015 / 09:00
0

Eu estava tendo exatamente o mesmo problema. No meu plugin, tenho tipos de post que são criados dinamicamente. Portanto, eles não podem ser registrados via register_post_type() em um método estático durante o activation_hook e, portanto, ainda não estão ativos quando flush_rewrite_rules() é executado durante esse hook (que normalmente é o codex forma recomendada das regras de reescrita de descarga).

A solução mais limpa que pude encontrar no final foi liberar as regras de reescrita após o registro dos tipos de post, mas é claro que somente se esse flush fosse realmente necessário (porque a operação é lenta). No meu caso, eu tenho vários tipos de post personalizado que herdam de uma única classe base e, portanto, era desejável implementar o código que faz o flush lá.

Se a limpeza é necessária, pode-se decidir observando a saída de get_option( 'rewrite_rules' ) :

class MyPostTypeClass {

public final function register_as_custom_post_type() {
    ...   //do all the setup of your post type here     
    $args = array(
                  ... //populate the other arguments as you see fit
                  'rewrite' => array('slug' => 'slug-of-your-post-type')
                 );
    register_post_type('post-type-name-of-your-post-type', $args );

    $rewrite_rules_must_be_fluhed = true;
    foreach( get_option( 'rewrite_rules' ) as $key => $rule)
        if(strpos($key, $args['rewrite']['slug'] ) === 0)
        {
            $rewrite_rules_must_be_fluhed = false;
            break;
        }
    if($rewrite_rules_must_be_fluhed)
        flush_rewrite_rules(true);
}
}

Desvantagens:

  • Depende, até certo ponto, de quais regras de reescrita exatas o WP gera durante register_post_type() .
  • Verificar se a limpeza é necessária durante cada carregamento de página também cria alguma sobrecarga.

Vantagens:

  • Totalmente encapsulado na classe que representa o tipo de postagem.
  • Apenas libera as regras de reescrita, se for realmente necessário.

Use isso somente se não puder registrar o tipo de postagem em uma função estática que possa chamar durante init e activation_hook !

A dependência de como as regras de reescrita geradas durante o register_post_type() se parecem pode ser mitigada substituindo o teste if(strpos($key, $args['rewrite']['slug'] ) === 0) por algo mais elaborado, ou seja, uma expressão regular.

    
por cgogolin 21.07.2018 / 11:08