Verifică actualizarea vs postare nouă în acțiunea save_post

Modul în care efectuez această verificare (în cadrul unei funcții hook) este să compar data postării cu data modificării (în GMT pentru standardizare)

function check_new_vs_update( $post_id ){
    $myPost     = get_post($post_id);
    $created    = new DateTime( $myPost->post_date_gmt );
    $modified   = new DateTime( $myPost->post_modified_gmt );
    $diff       = $created->diff( $modified );
    $seconds_difference = ((($diff->y * 365.25 + $diff->m * 30 + $diff->d) * 24 + $diff->h) * 60 + $diff->i)*60 + $diff->s;

    if( $seconds_difference <= 1 ){
        // Postare nouă
    }else{
        // Postare actualizată
    }
}
add_action('save_post', 'check_new_vs_update' );

Această metodă funcționează deoarece chiar și la creare, postarea are o dată 'modificată' atașată, care este exact aceeași cu data 'creării', dar permitem o variație de 1 secundă în cazul în care o secundă trece în timpul creării postării.

Am ales să verific pur și simplu existența unei valori personalizate înainte de a o seta. În acest fel, dacă este un post nou creat, valoarea personalizată nu ar exista încă.

function attributes_save_postdata($post_id) {
  if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) return;
  if (!wp_verify_nonce($_POST['_attributes_noncename'], plugin_basename(__FILE__))) return;
  if ('page' == $_POST['post_type']) {
    if (!current_user_can('edit_page', $post_id)) return;
  } else {
    if (!current_user_can('edit_post', $post_id)) return;
  }
  $termid = get_post_meta($post_id, '_termid', true);
  if ($termid != '') {
    // este o înregistrare nouă
    $termid = 'update';
  } else {
    // este o înregistrare existentă
  }
  update_post_meta($post_id, '_termid', $termid);
}
add_action('save_post', 'attributes_save_postdata');

Exemplu de răspuns pentru ialocin cu parametrul "update":

function save_func($ID, $post,$update) {

   if($update == false) {
     // faci ceva dacă este prima publicare
   } else {
     // Faci ceva dacă este o actualizare
   }
}

add_action( 'save_post', 'save_func', 10, 3 );

Am întâlnit recent hook-ul save_post legat de crearea și actualizarea postărilor. După ce am citit codul sursă pentru a înțelege fluxul, am descoperit că următoarea metodă ar putea fi utilă. Deoarece nu a fost menționată anterior, o împărtășesc în caz că ar fi de folos cuiva. (Testat pe versiunea WordPress 5.3.3)

Fluxul de creare a unei postări este aproximativ:

1. După apăsarea butonului "Adaugă nou" (Postare)
2. Se apelează $post = get_default_post_to_edit( $post_type, true ); unde
3. get_default_post_to_edit() primește argumentul $create_in_db = true
4. astfel wp_insert_post() este apelat imediat, se creează o postare auto-draft, chiar dacă nu este salvată. De fiecare dată când se apasă Adaugă nou, se creează un auto-draft
5. $update este întotdeauna true pentru publicare. Deci, când se publică o postare nouă, valoarea este true.

Comparând obiectul $_POST pentru o postare nouă și una actualizată sau republicată, diferența evidentă este valoarea _wp_http_referer. Pentru postările noi, valoarea este /wp-admin/post-new.php.

Presupunere: se presupune că postarea este publicată/adaugată din interfața de utilizator. Dacă acest lucru se face prin alte mecanisme sau cod personalizat, verificarea trebuie ajustată corespunzător.

add_action( 'save_post', 'test_save_post_check', 0, 3 );
function test_save_post_check( $post_ID, $post, $update ) {
    // alte verificări + aceasta
    // verificarea prezenței 'post-new' în '_wp_http_referer'
    if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ) {
        // postare nouă
    } else {
        // actualizare
    }
}

aici este un cod funcțional pe care l-am testat și l-am folosit pe site-ul meu, care rezolvă următoarele două probleme asociate cu acțiunea save_post:

1. problema de a verifica între actualizare sau inserare

2. problema inserării de două ori prin acțiunea save_post

   function save_annonces_callback($post_ID, $post, $update){
   
           $post_type = get_post_type($post_ID);
   
           if ( $post_type === 'annonces' ){
   
               //acest lucru previne inserarea de două ori prin acțiunea save_post :)
               if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE ) {
                   return;
               } else {
   
                   //verifică dacă este un post nou, deci inserează
                   if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ){
   
                       //efectuează inserarea
   
                   }else{
   
                       //efectuează actualizarea
                   }
   
               }
   
           }
       }add_action('save_post','save_annonces_callback', 10, 3);
   

Puteți utiliza acțiunea (hook) `pre_post_update` pentru codul de actualizare și `save_post` pentru codul de postare nouă. Acesta funcționează înainte ca un articol să fie actualizat.

După cum a sugerat Darshan Thanki (și Stephen Harris a dezvoltat în continuare), puteți utiliza pre_post_update în avantajul vostru.

global $___new_post;
$___new_post = true;

add_action(
  'pre_post_update',
  function() {
    global $___new_post;
    $___new_post = false;
  },
  0
);

function is_new_post() {
  global $___new_post;
  return $___new_post;
}

Motivul pentru care am folosit variabile globale este pentru că function is_new_post() use ( &$new_post ) nu este valid în PHP (șocant...) așa că includerea acelei variabile în scope-ul funcției nu funcționează -- de aceea am folosit global.

Rețineți că această soluție poate fi folosită în mod fiabil doar în cadrul sau după evenimentul save_post (ceea ce este de obicei suficient, cel puțin pentru ceea ce facem noi cu ea).

Când acțiunea save_post este declanșată, toate informațiile despre acel articol sunt deja disponibile, așa că teoretic ai putea folosi

function f4553265_check_post() {

    if (!get_posts($post_id)) {
    // dacă acesta este un articol nou, get_posts($post_id) ar trebui să returneze null
    } else {
    // $post_id există deja în baza de date
    }
}
add_action('save_post','f4553265_check_post');

această soluție nu a fost testată, totuși. =)

O altă abordare care folosește o funcție încorporată și nu necesită adăugări în baza de date ar implica get_post_status().

$post_status = get_post_status();
if ( $post_status != 'draft' ) {
    //schiță
} else { 
    //nu este o schiță: poate fi publicat, în așteptare, etc.
}

Totuși, rețineți că poate să nu fie potrivit dacă intenționați să setați ulterior starea înapoi la "draft" - instrucțiunile dvs. vor fi repetate data viitoare când veți actualiza postarea. În funcție de context, s-ar putea să doriți să luați în considerare diferitele șiruri returnate de get_post_status() pentru a construi un scenariu mai potrivit.

Consultați Codex pentru get_post_status() și Starea Postării

Valorile posibile sunt:

• 'publish' - O postare sau pagină publicată
• 'pending' - postarea așteaptă moderare
• 'draft' - o postare în stadiu de schiță
• 'auto-draft' - o postare nou creată, fără conținut
• 'future' - o postare programată pentru publicare în viitor
• 'private' - nu este vizibilă pentru utilizatorii nelogati
• 'inherit' - o revizie. vezi get_children.
• 'trash' - postarea este în coșul de gunoi. adăugat începând cu Versiunea 2.9.

Deoarece parametrul $update este inutil, acesta este cel mai rapid mod pe care l-am testat:

function wpse48678_check_is_post_new($post_id, $post, $update)
{
    if (false !== strpos($_POST['_wp_http_referer'], 'post-new.php')) {
        return true; // Sau fă altceva.
    } else {
        return false; // Sau fă altceva.
    }
}
add_action('save_post_{$post_type}', 'wpse48678_check_is_post_new', 10, 3);

Am petrecut ore întregi pe asta

În prezent sunt în procesul de dezvoltare a unui plugin și am vrut să trimit o notificare tuturor autorilor atunci când o pagină era "Creată" pe site-ul companiei mele de Web Design.

Inițial am încercat să folosesc următoarele:

add_action('save_post_page', function($post_id, $post, $update) {
    if(!$update){
        echo("Este un post nou!");
    }else{
        echo("Este un post vechi!");
    }
}

Continuam să afișeze "Este un post vechi!". Dar de ce??? După ce am cercetat, am aflat că după ce apeși butonul "Adaugă Pagină Nouă", WordPress creează instantaneu un auto-draft care setează variabila $update la true. Cât de util.

După ore de cercetare, am găsit în sfârșit următoarea soluție care funcționează:

// Se declanșează când un post își schimbă "statusul", de ex. din pending în draft, publicat în programat.
add_action('transition_post_status', function($new_status, $old_status, $post) {
    // Verifică dacă postul trece de la auto-draft la orice alt status (draft, pending, publish, etc.)
    if 'auto-draft' === $old_status && $new_status !== 'auto-draft'){
        echo("Este un post nou!");
    }else{
        echo("Este un post vechi!");
    }
}

Notă: În WordPress, "draft" și "auto-draft" sunt diferite. Un status "draft" este un post pe care utilizatorul îl setează manual ca draft, indicând faptul că este în lucru. Pe de altă parte, "auto-draft" este atribuit automat unui post atunci când este creat dar încă nepublicat. Practic, un alt mod de a spune auto-salvare.

Sper că acest lucru va ajuta câteva persoane... E timpul să mai petrec încă 4 ore pe o altă problemă haha.

Ar trebui să funcționeze, băieți

add_action( 'wp_after_insert_post', 'clearCDNCache', 10, 4);       
 
public function clearCDNCache($post_id, $post, $update, $post_before){
        
        if ( ! empty($_POST['_wpnonce']) ) {
            // Execută funcția personalizată doar o dată
        }
    
        // Adaugă un nou mod
        if (!empty($_POST['_wp_http_referer']) && $_POST['_wp_http_referer'] == '/wp-admin/post-new.php') { 

        } else {
            // Modul de actualizare
        }
       
    }