Unde, Când și Cum să Goliți Corect Regulile de Rescriere în Contextul unui Plugin?

Cel mai bun loc pentru a reseta regulile de rescriere este la activarea/dezactivarea plugin-ului.

function myplugin_activate() {
    // înregistrează taxonomii/tipuri de postări aici
    flush_rewrite_rules();
}

register_activation_hook( __FILE__, 'myplugin_activate' );

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

Vezi articolul din codex

Îmi cer scuze anticipat, nu am reușit să parcurg întrebarea ta complet, așa că acesta este un răspuns standard.

Este greu de spus ce nu funcționează fără a vedea codul tău. Dar după salvarea unor setări, este practic să folosești hook-ul admin_init așa cum este arătat mai jos pentru a reîncărca regulile de rescriere.

Cod:

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

Trebuie să setezi opțiunea undeva pe pagina de setări sau mai exact undeva în procesul de salvare a setărilor. A face acest lucru fără opțiune este prost, pentru că nu vrei să reîncarci regulile de fiecare dată.

Notă: netestat

Aveam un fișier de clasă pentru tipurile de postări care era responsabil cu citirea setărilor opțiunilor plugin-ului și crearea tipurilor de postări personalizate necesare pe baza setărilor specificate de utilizator.

Acest fișier de clasă pentru tipurile de postări era încărcat pe hook-ul init.

Am crezut că tot ce trebuie să fac este să actualizez setările plugin-ului, apoi să resetez regulile de rescriere. Deoarece clasa pentru tipurile de postări era deja încărcată pe baza setărilor plugin-ului. Dar cu paginile de administrare, acestea sunt încărcate DUPĂ hook-ul init.

Tipurile de postări nu au fost niciodată înregistrate, deoarece setările nu erau de fapt setate încă. Clasa de înregistrare a tipurilor de postări a fost întreruptă prematur fără ca vreun tip de postare să fie înregistrat.

Soluția a fost:

1. Actualizați setările plugin-ului.
2. Încărcați fișierul clasei pentru tipurile de postări DOAR o dată aici, astfel încât noile reguli de rescriere să fie create.
3. Resetați regulile de rescriere.

(Anterior... pasul 2 lipsea -- După cum am menționat mai sus...)

De acum încolo, tipurile de postări vor fi încărcate pe hook-ul init și vor avea setările deja specificate, permițând crearea tipurilor de postări și asocierea lor cu regulile de rescriere adecvate.

Din nu știu ce motiv, a trebuit să adaug un apel JavaScript pentru a redirecționa către pagina curentă, după efectuarea celor trei pași de mai sus.

De asemenea, a trebuit să adaug un apel la flush_rewrite_rules(); pe pagina de setări de administrare a plugin-ului.

Deci, pentru a mă asigura că totul este resetat...

Pasul 1) Navigați la pagina de setări de administrare a plugin-ului. -- Resetare inițială.

Pasul 2) Actualizați setările plugin-ului. -- A doua resetare.

Pasul 3) Pagina se redirecționează către pagina de setări a plugin-ului. Cauzând... A treia și ultima resetare (la fel ca resetarea inițială -- Se face automat când se vizitează pagina de setări a plugin-ului)

Nu spun că aceasta este o soluție practică, dar a funcționat pentru mine. O problemă foarte ciudată și cel mai probabil are legătură cu infrastructura mea de codare.

Aveam exact aceeași problemă. În plugin-ul meu, am tipuri de postări care sunt create dinamic. Prin urmare, ele nu pot fi înregistrate prin register_post_type() într-o metodă statică în timpul activation_hook și, astfel, nu sunt încă active când flush_rewrite_rules() este executat în acest hook (care este în mod normal metoda recomandată de a reîmprospăta regulile de rescriere).

Cea mai curată soluție la care am putut ajunge în final a fost să reîmprospăt regulile de rescriere după înregistrarea tipurilor de postări, dar, desigur, doar dacă o astfel de reîmprospătare era cu adevărat necesară (deoarece operația este lentă). În cazul meu, am de fapt mai multe tipuri de postări personalizate care moștenesc dintr-o singură clasă de bază, așa că a fost de dorit să implementez codul care face reîmprospătarea acolo.

Dacă reîmprospătarea este necesară poate fi decisă prin examinarea rezultatului get_option( 'rewrite_rules' ):

class MyPostTypeClass {

public final function register_as_custom_post_type() {
    ...   //fă toată configurarea tipului tău de postare aici     
    $args = array(
                  ... //completează celelalte argumente după cum consideri potrivit
                  '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);
}
}

Dezavantaje:

• Se bazează într-o oarecare măsură pe exact ce reguli de rescriere generează WP în timpul register_post_type().
• Verificarea dacă reîmprospătarea este necesară în timpul fiecărei încărcări de pagină creează și ea o anumită suprasarcină.

Avantaje:

• Complet încapsulat în clasa care reprezintă tipul de postare.
• Reîmprospătează regulile de rescriere doar dacă este cu adevărat necesar.

Folosește această soluție doar dacă nu poți înregistra tipul tău de postare într-o funcție statică care poate fi apelată atât în init cât și în activation_hook!

Dependența de modul în care arată regulile de rescriere generate în timpul register_post_type() poate fi atenuată prin înlocuirea testului if(strpos($key, $args['rewrite']['slug'] ) === 0) cu ceva mai elaborat, de exemplu, o expresie regulată.

@tazo-todua asta a funcționat și pentru mine când am folosit 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();
}

Dacă dorești să apelezi flush_rewrite_rules atunci când ORICE plugin este activat sau dezactivat

add_action('init', function(){

    // Obține calea fiecărui plugin instalat
    $pluginsInstalledPaths = glob(WP_PLUGIN_DIR . '/*', GLOB_ONLYDIR);

    foreach ($pluginsInstalledPaths as $pluginPath) {
        // Obține toate fișierele PHP disponibile în directorul rădăcină al pluginului
        $files = glob($pluginPath . '/*.php');
        foreach ($files as $file) {
            $contents = file_get_contents($file);
            // Dacă fișierul conține "Plugin Name" înseamnă că este fișierul principal al pluginului
            if (preg_match('/\/\*\*[^\/]*?Plugin Name:/', $contents)) {
                add_action('activate_' . plugin_basename($file), function(){
                    flush_rewrite_rules();
                });
                add_action('deactivate_' . plugin_basename($file), function(){
                    flush_rewrite_rules();
                });
            }
        }
    }
});

SOLUȚIA PE CARE AM GĂSIT-O A FOST:

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

Adaugă acest cod ori de câte ori dorești să resetezi regulile de rescriere, de exemplu la activarea plugin-ului tău sau la orice eveniment dorit.

add_action('init','flush_rewrite_rules');