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.

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

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.

@ 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();
}

MINHA SOLUÇÃO encontrada FOI:

global $wp_rewrite; $wp_rewrite->flush_rules(); $wp_rewrite->init();

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.