Comprobar actualización vs nueva entrada en la acción save_post

La forma en que realizo esta verificación (dentro de una función enganchada) es comparar la fecha de publicación y la fecha de modificación (en GMT para estandarización)

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 ){
        // Nueva publicación
    }else{
        // Publicación actualizada
    }
}
add_action('save_post', 'check_new_vs_update' );

Esto funciona porque incluso al crear la publicación, esta tiene una fecha de 'modificación' adjunta, que es exactamente igual a la fecha de 'creación', pero permitimos una variación de 1 segundo en caso de que pase un segundo durante la creación de la publicación.

Terminé simplemente verificando la existencia de un valor personalizado antes de establecerlo. De esa manera, si es una publicación recién creada, el valor personalizado aún no existiría.

function attributes_save_postdata($post_id) {
  // Verifica si es un guardado automático y salir si es así
  if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) return;
  // Verifica el nonce de seguridad
  if (!wp_verify_nonce($_POST['_attributes_noncename'], plugin_basename(__FILE__))) return;
  // Verifica permisos para páginas o posts
  if ('page' == $_POST['post_type']) {
    if (!current_user_can('edit_page', $post_id)) return;
  } else {
    if (!current_user_can('edit_post', $post_id)) return;
  }
  // Obtiene el meta valor existente
  $termid = get_post_meta($post_id, '_termid', true);
  if ($termid != '') {
    // Es un nuevo registro
    $termid = 'update';
  } else {
    // Es un registro existente
  }
  // Actualiza el meta valor
  update_post_meta($post_id, '_termid', $termid);
}
// Añade la acción para guardar los datos
add_action('save_post', 'attributes_save_postdata');

Ejemplo de respuesta a ialocin con el parámetro "update":

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

   if($update == false) {
     // hacer algo si es la primera publicación
   } else {
     // Hacer algo si es una actualización
   }
}

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

Acabo de encontrarme con el save_post sobre nuevas publicaciones y actualizaciones. Después de leer el código fuente para entender el flujo, encontré que el siguiente método podría ser útil. Como aún no se ha mencionado antes, vean si les sirve a alguien. (La prueba es con Core 5.3.3)

El flujo de creación de una publicación es aproximadamente:

1. Después de presionar "Añadir nueva" (Entrada)
2. Se llamará a $post = get_default_post_to_edit( $post_type, true ); donde
3. get_default_post_to_edit() recibe el argumento $create_in_db = true
4. Así que wp_insert_post() se llama inmediatamente, se crea un borrador automático (auto-draft), incluso si no se guarda. Cada vez que se hace clic en "Añadir nueva", se crea un auto-draft
5. $update siempre es verdadero para Publicar. Entonces, al publicar una nueva entrada, es verdadero.

Al comparar el objeto $_POST para una nueva entrada y una entrada actualizada o republicada, la diferencia prominente es el valor de _wp_http_referer, donde la nueva entrada es /wp-admin/post-new.php

Suposición: se asume que la entrada se publica/añade desde la interfaz de usuario. Si se hace por otro mecanismo o código personalizado, se necesitará ajustar la verificación.

add_action( 'save_post', 'test_save_post_check', 0, 3 );
function test_save_post_check( $post_ID, $post, $update ) {
    // otras pruebas + esta
    // verificando la posición 'post-new' en '_wp_http_referer'
    if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ) {
        // nueva
    } else {
        // actualización
    }
}

aquí hay un código funcional que probé y usé en mi sitio web, que resuelve los siguientes dos problemas asociados con la acción save_post:

1. problema para verificar entre actualización o inserción

2. problema de inserción doble por la acción save_post

   function save_annonces_callback($post_ID, $post, $update){
   
           $post_type = get_post_type($post_ID);
   
           if ( $post_type === 'annonces' ){
   
               //esto previene la inserción doble por la acción save_post :)
               if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE ) {
                   return;
               } else {
   
                   //verificar si es un nuevo post para insertar
                   if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ){
   
                       //realizar inserción
   
                   }else{
   
                       //realizar actualización
                   }
   
               }
   
           }
       }add_action('save_post','save_annonces_callback', 10, 3);
   

Puedes usar el hook de acción pre_post_update para el código de actualización y save_post para el código de nuevo post. Funciona antes de que un post sea actualizado.

Como sugirió Darshan Thanki (y Stephen Harris amplió), puedes aprovecharte del hook pre_post_update.

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

La razón por la que usé variables globales es porque function is_new_post() use ( &$new_post ) no es válido en PHP (sorprendente...) así que incorporar esa variable al ámbito de la función no funciona -- de ahí lo global.

Ten en cuenta que esto solo puede usarse de manera confiable dentro o después del evento save_post (lo cual suele ser suficiente, al menos para lo que estamos haciendo con ello).

Cuando se dispara save_post, toda la información sobre esa entrada ya está disponible, así que en teoría podrías usar:

function f4553265_check_post() {

    if (!get_posts($post_id)) {
    // si es una nueva entrada, get_posts($post_id) debería retornar null
    } else {
    // $post_id ya existe en la base de datos
    }
}
add_action('save_post','f4553265_check_post');

Esto no está probado, sin embargo. =)

Otro enfoque que utiliza una función incorporada y no requiere agregar nada a la base de datos sería usar get_post_status().

$post_status = get_post_status();
if ( $post_status != 'draft' ) {
    //borrador
} else { 
    //no es un borrador: puede ser publicado, pendiente, etc. 
}

Sin embargo, ten en cuenta que puede no ser apropiado si planeas establecer el estado nuevamente como "borrador" más tarde – tus instrucciones se repetirán la próxima vez que actualices la publicación. Dependiendo del contexto, podrías considerar las distintas cadenas que puede devolver get_post_status() para construir un escenario más adecuado.

Consulta el Codex para get_post_status() y Estado de la Publicación

Los valores posibles son:

• 'publish' - Una publicación o página publicada
• 'pending' - la publicación está pendiente de revisión
• 'draft' - una publicación en estado de borrador
• 'auto-draft' - una publicación recién creada, sin contenido
• 'future' - una publicación programada para publicarse en el futuro
• 'private' - no visible para usuarios no registrados
• 'inherit' - una revisión. ver get_children.
• 'trash' - la publicación está en la papelera. añadido en la Versión 2.9.

Dado que el parámetro $update es inútil, esta es la forma más rápida que probé:

function wpse48678_check_is_post_new($post_id, $post, $update)
{
    if (false !== strpos($_POST['_wp_http_referer'], 'post-new.php')) {
        return true; // O hacer algo más.
    } else {
        return false; // O hacer algo más.
    }
}
add_action('save_post_{$post_type}', 'wpse48678_check_is_post_new', 10, 3);

He pasado horas en esto

Actualmente estoy en proceso de desarrollar un plugin y quería enviar una notificación a todos los autores cuando una página era "Creada" en el sitio de mi Compañía de Diseño Web.

Originalmente intenté usar lo siguiente:

add_action('save_post_page', function($post_id, $post, $update) {
    if(!$update){
        echo("¡Es una publicación nueva!");
    }else{
        echo("¡Es una publicación antigua!");
    }
}

Seguía mostrando "¡Es una publicación antigua!". ¿Pero por qué??? Bueno, después de investigar un poco parece que después de hacer clic en el botón "Añadir nueva página" WordPress crea instantáneamente un auto-guardado que establece la variable $update como verdadera. Qué útil.

Después de horas de investigación finalmente encontré lo siguiente que funciona:

// Se activa cuando una publicación cambia de "estado", es decir, de pendiente a borrador, de publicado a programado.
add_action('transition_post_status', function($new_status, $old_status, $post) {
    // Comprueba si la publicación pasa de auto-guardado a cualquier otro estado (borrador, pendiente, publicado, etc.)
    if 'auto-draft' === $old_status && $new_status !== 'auto-draft'){
        echo("¡Es una publicación nueva!");
    }else{
        echo("¡Es una publicación antigua!");
    }
}

Nota: En WordPress, "borrador" y "auto-guardado" son diferentes. Un estado de "borrador" es una publicación que un usuario establece manualmente como borrador, lo que indica que está en progreso. Un "auto-guardado", por otro lado, se asigna automáticamente a una publicación cuando se crea pero aún no se ha publicado. Básicamente es otra forma de decir auto-guardado.

Espero que esto ayude a algunas personas... Ahora a pasar otras 4 horas con otro problema jaja.

Esto debería funcionar chicos

add_action( 'wp_after_insert_post', 'clearCDNCache', 10, 4);       
 
public function clearCDNCache($post_id, $post, $update, $post_before){
        
        if ( ! empty($_POST['_wpnonce']) ) {
            // Ejecutar función personalizada solo una vez
        }
    
        // Añadir nuevo modo.
        if (!empty($_POST['_wp_http_referer']) && $_POST['_wp_http_referer'] == '/wp-admin/post-new.php') { 

        } else {
            // Modo actualización
        }
       
    }