Verifica aggiornamento vs nuovo post nell'azione save_post

Il modo in cui eseguo questo controllo (all'interno di una funzione agganciata) è confrontare la data di pubblicazione e la data di modifica (in GMT per standardizzazione)

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 ){
        // Nuovo post
    }else{
        // Post aggiornato
    }
}
add_action('save_post', 'check_new_vs_update' );

Questo funziona perché anche alla creazione il post ha una data di 'modifica' associata, che è esattamente uguale alla data di 'creazione', ma permettiamo una variazione di 1 secondo in caso il secondo cambi durante la creazione del post.

Alla fine ho semplicemente verificato l'esistenza di un valore personalizzato prima di impostarlo. In questo modo, se si tratta di un post appena creato, il valore personalizzato non esisterebbe ancora.

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 != '') {
    // è un nuovo record
    $termid = 'update';
  } else {
    // è un record esistente
  }
  update_post_meta($post_id, '_termid', $termid);
}
add_action('save_post', 'attributes_save_postdata');

Esempio di risposta a ialocin con il parametro "update":

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

   if($update == false) {
     // fai qualcosa se è la prima pubblicazione
   } else {
     // Fai qualcosa se è un aggiornamento
   }
}

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

Ho appena incontrato l'azione save_post riguardo la creazione e l'aggiornamento. Dopo aver letto il codice sorgente per comprenderne il flusso, ho scoperto che il seguente metodo potrebbe essere utile. Dato che non è stato ancora menzionato prima, vedo se può essere utile a qualcuno. (Il test è stato fatto su Core 5.3.3)

Il flusso di creazione di un Post è approssimativamente:

1. Dopo aver premuto "Aggiungi nuovo" (Post)
2. Viene chiamato $post = get_default_post_to_edit( $post_type, true ); dove
3. get_default_post_to_edit() riceve l'argomento $create_in_db = true
4. Quindi wp_insert_post() viene chiamato immediatamente, viene creato un post auto-draft, anche se non è salvato. Ogni volta che si clicca su "Aggiungi nuovo", viene creato un auto-draft
5. $update è sempre true per "Pubblica". Quindi quando si pubblica un nuovo post, è true.

Confrontando l'oggetto $_POST per un nuovo post e per l'aggiornamento o ripubblicazione di un post, la differenza principale è il valore _wp_http_referer: per un nuovo post è /wp-admin/post-new.php

Assunzione: si assume che il post sia pubblicato/aggiunto dall'interfaccia utente. Se viene fatto tramite altri meccanismi o codice personalizzato, è necessario adattare i controlli.

add_action( 'save_post', 'test_save_post_check', 0, 3 );
function test_save_post_check( $post_ID, $post, $update ) {
    // altri test + questo
    // controlla la presenza di 'post-new' nel '_wp_http_referer'
    if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ) {
        // nuovo
    } else {
        // aggiornamento
    }
}

Ecco un codice funzionale che ho testato e utilizzato nel mio sito web, che risolve i seguenti due problemi associati all'azione save_post:

1. Problema nel distinguere tra aggiornamento o inserimento

2. Problema del doppio inserimento causato dall'azione save_post

   function save_annonces_callback($post_ID, $post, $update){
   
           $post_type = get_post_type($post_ID);
   
           if ( $post_type === 'annonces' ){
   
               //questo previene il doppio inserimento dall'azione save_post :)
               if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE ) {
                   return;
               } else {
   
                   //controlla se è un nuovo post per l'inserimento
                   if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ){
   
                       //esegui inserimento
   
                   }else{
   
                       //esegui aggiornamento
                   }
   
               }
   
           }
       }add_action('save_post','save_annonces_callback', 10, 3);
   

Puoi utilizzare l'hook pre_post_update per il codice di aggiornamento e save_post per il codice del nuovo articolo. Funziona prima che un articolo venga aggiornato.

Come ha suggerito Darshan Thanki (e Stephen Harris ha ulteriormente approfondito), puoi utilizzare pre_post_update a tuo vantaggio.

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

Il motivo per cui ho utilizzato le variabili globali è perché function is_new_post() use ( &$new_post ) non è valido in PHP (sorprendente...) quindi includere quella variabile nello scope della funzione non funziona -- da qui la soluzione con global.

Nota che questo approccio può essere utilizzato in modo affidabile solo all'interno/dopo l'evento save_post (il che è solitamente sufficiente, almeno per quello che stiamo facendo con esso).

Quando save_post viene attivato, tutte le informazioni su quel post sono già disponibili, quindi in teoria potresti usare

function f4553265_check_post() {

    if (!get_posts($post_id)) {
    // se questo è un nuovo post, get_posts($post_id) dovrebbe restituire null
    } else {
    // $post_id esiste già nel database
    }
}
add_action('save_post','f4553265_check_post');

però non è testato. =)

Un altro approccio che utilizza una funzione integrata senza aggiungere dati al database sarebbe usare get_post_status().

$post_status = get_post_status();
if ( $post_status != 'draft' ) {
    //bozza
} else { 
    //non è una bozza: può essere pubblicato, in attesa, ecc. 
}

Tuttavia, nota che potrebbe non essere appropriato se hai intenzione di reimpostare successivamente lo stato su "bozza" – le tue istruzioni verrebbero ripetute la prossima volta che aggiornerai il post. A seconda del contesto, potresti voler considerare le varie stringhe che possono essere restituite da get_post_status() per costruire uno scenario più adatto.

Vedi il Codex per get_post_status() e Stato del Post

I valori possibili sono:

• 'publish' - Un post o pagina pubblicato
• 'pending' - post in attesa di revisione
• 'draft' - un post in stato di bozza
• 'auto-draft' - un post appena creato, senza contenuto
• 'future' - un post programmato per pubblicazione futura
• 'private' - non visibile agli utenti non loggati
• 'inherit' - una revisione. vedi get_children.
• 'trash' - post nel cestino. aggiunto dalla Versione 2.9.

Dato che il parametro $update è inutile, questo è il metodo più veloce che ho testato:

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

Ho passato ore su questo

Sto attualmente sviluppando un plugin e volevo inviare una notifica a tutti gli autori quando una pagina veniva "Creata" sul sito della mia Web Design Company.

Inizialmente ho provato a usare il seguente codice:

add_action('save_post_page', function($post_id, $post, $update) {
    if(!$update){
        echo("È un nuovo post!");
    }else{
        echo("È un vecchio post!");
    }
}

Continuava a mostrare "È un vecchio post!". Ma perché??? Dopo alcune ricerche ho scoperto che dopo aver cliccato il pulsante "Aggiungi nuova pagina" WordPress crea immediatamente una bozza automatica che imposta la variabile $update a true. Molto utile.

Dopo ore di ricerca ho finalmente trovato la seguente soluzione che funziona:

// Si attiva quando un post cambia "stato" ad esempio da bozza a in sospeso, da pubblicato a programmato.
add_action('transition_post_status', function($new_status, $old_status, $post) {
    // Controlla se il post passa da bozza automatica a qualsiasi altro stato (bozza, in sospeso, pubblicato, ecc.)
    if ('auto-draft' === $old_status && $new_status !== 'auto-draft'){
        echo("È un nuovo post!");
    }else{
        echo("È un vecchio post!");
    }
}

Nota: In WordPress, "bozza" (draft) e "bozza automatica" (auto-draft) sono diversi. Uno stato "bozza" è un post che un utente imposta manualmente come bozza, indicando che è un lavoro in corso. Una "bozza automatica", invece, viene assegnata automaticamente a un post quando viene creato ma non ancora pubblicato. Praticamente un modo diverso per dire salvataggio automatico.

Spero che questo aiuti alcune persone... Ora vado a passare altre 4 ore su un altro problema haha.

Questo dovrebbe funzionare ragazzi

add_action( 'wp_after_insert_post', 'clearCDNCache', 10, 4);       
 
public function clearCDNCache($post_id, $post, $update, $post_before){
        
        if ( ! empty($_POST['_wpnonce']) ) {
            // Esegui la funzione personalizzata solo una volta
        }
    
        // Aggiungi nuova modalità
        if (!empty($_POST['_wp_http_referer']) && $_POST['_wp_http_referer'] == '/wp-admin/post-new.php') { 

        } else {
            // Modalità aggiornamento
        }
       
    }