Vérifier la mise à jour par rapport au nouveau message sur l'action save_post

Depuis la version 3.7 de WordPress. - IIRC - le hook save_post -plus d'informations sur le hooket son utilisation sur Référence de code: save_post et Codex: save_post - a untroisièmeparamètre $ update quipeut être utilisépour déterminerexactement cela.

@param      int                             $post_ID       Identifiant dumessage.
@param       WP_Post         $publier                 Objet dumessage.
@param      booléen                     $mettre àjour       S'il s'agit d'unmessageexistanten cours demise àjour ounon.

Remarque :

$ update n'estpastoujours true - vouspouvez le voiret letester vous-même avec le code ci-dessous. Iln'est cependantpasbien documenté,peut-être loin d'êtrenommé demanière optimale,et crée donc des attentestrompeuses. Le code ci-dessouspeut être utilisépour certains débogages,jouez avec quandintercepter l'exécution du code,sinon vousne verrezpas lesinformations/messages. Jepense que le coupable d'un comportementtrompeurest lagestion des révisionset des sauvegardes automatiques - quipourraient être désactivées,maisje ne le recommandepaset jene l'aipastesté. Jene saispas si celajustifie un ticket Trac ,doncje n'en aipas ouvert,si vouspensez que oui,veuillez suivre le lienet faites-le vous-même. En dehors de cela,commeindiqué dans les commentaires,si vous avez unproblème spécifique,postez unenouvelle question.

  add_action ('save_post','debug_save_post_update',10,3);
function debug_save_post_update ($ ID,$post,$ update) {

 echo '& lt;pre >';
 print_r ($post);echo '& lt;br >';
 echo '$ update==';
 echo $ update? 'vraifaux';

//conditions
 if (! $ update & amp; & amp; $post- >post_status=="auto-draft") {
//s'applique à unnouveaumessage
 echo '& amp; & amp; $post- >post_status=="brouillon automatique" ';
//mourir();
  }elseif (! $ update) {
//s'appliqueessentiellement à la révision (enregistrée automatiquement)
//mourir();
  } autre {
//s'applique à lamise àjour d'un articlepublié
//lorsqu'il y a une révision,ce quiestnormalement le cas,
//comportement standard de WordPress,alorsilest considéré
//unemise àjour,là où la confusion s'installe
//ilexiste d'autresméthodes,comme vérifier l'heure ou l'état de lapublication
//selon votre cas d'utilisation,celapourrait êtreplus approprié
//pour utiliser l'une de ces alternatives
//mourir();
  }

 echo '& lt;/pre >';
//mourir();
}
 

Since WordPress version 3.7. - IIRC - the save_post hook - more information about the hook and its usage at Code Reference: save_post and Codex: save_post - has a third parameter $update which can be used to determine just that.

@param     int               $post_ID     Post ID.
@param     WP_Post     $post          Post object.
@param     bool            $update     Whether this is an existing post being updated or not.

Note:

$update is not always true – you can see and test it yourself with below code. It is not well documented though, possibly far from optimally named, and hence creates misleading expectations. Below code can be used for some debugging, play around with when to intercept code execution, because otherwise you won't see the information/messages. I think, the culprit in deceptive behavior is the handling of revisions and auto saves – which could be disabled, but I don't recommend it, and haven't tested it. Not sure if this warrants a Trac Ticket, so I didn't open one, if you think so, please follow the link and do it yourself. Aside from that, as stated in the comments, if you have a specific problem, post a new question.

add_action( 'save_post', 'debug_save_post_update', 10, 3 );
function debug_save_post_update( $ID, $post, $update ) {

  echo '<pre>';
  print_r( $post ); echo '<br>';
  echo '$update == ';
  echo $update ? 'true' : 'false';

  //conditions
  if( ! $update && $post->post_status == "auto-draft" ) {
    // applies to new post
    echo ' && $post->post_status == "auto-draft"';
    //die();
  } else if ( ! $update ) {
    // applies basically to the (auto saved) revision 
    //die();
  } else {
    // applies to updating a published post
    // when there is a revision, which is normally the case, 
    // standard behavior of WordPress, then it is considered 
    // an update, which is where the confusion sets in
    // there are other methods, like checking time or post status
    // depending on your use case it might be more appropriate 
    // to use one of those alternatives 
    //die();
  }

  echo '</pre>';
  //die();
}

Lafaçon dontj'effectue cette vérification (dans unefonction accrochée)est de comparer la date depublicationet la date demodification (en GMTpour lanormalisation)

 function check_new_vs_update( $post_id ){
    $myPost        = get_post($post_id);
    $post_created  = new DateTime( $myPost->post_date_gmt );
    $post_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 ){
        // New post
    }else{
        // Updated post
    }
}
add_action('save_post', 'check_new_vs_update' );
 

Celafonctionneparce quemême à la création,lapublication a une date 'modifiée' qui luiest attachée,quiestexactement lamême que la date 'créée',maisnous autorisons une variation de 1 seconde dans les deux cas au cas où une seconde cochependantla création dumessage.

The way I perform this check (within a hooked function) is to compare the post date and modified date (in GMT for standardisation)

function check_new_vs_update( $post_id ){
    $myPost        = get_post($post_id);
    $post_created  = new DateTime( $myPost->post_date_gmt );
    $post_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 ){
        // New post
    }else{
        // Updated post
    }
}
add_action('save_post', 'check_new_vs_update' );

This works because even at creation the post has a 'modified' date attached to it, which is exactly the same as the 'created' date, but we allow a variance of 1 second either way in case a second ticks over during the creation of the post.

J'aifini par vérifier simplement l'existence d'une valeurpersonnalisée avant de la définir.De cettefaçon,s'il s'agit d'un articlenouvellement créé,la valeurpersonnaliséen'existeraitpasencore.

 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 != '') {
    // it's a new record
    $termid = 'update';
  } else {
    // it's an existing record
  }
  update_post_meta($post_id, '_termid', $termid);
}
add_action('save_post', 'attributes_save_postdata');
 

I ended up just checking for the existence of a custom value prior to setting it. That way, if it's a newly created post the custom value would not yet exist.

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 != '') {
    // it's a new record
    $termid = 'update';
  } else {
    // it's an existing record
  }
  update_post_meta($post_id, '_termid', $termid);
}
add_action('save_post', 'attributes_save_postdata');

Exemple de réponseialocin avec leparamètre "update":

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

   if($update == false) {
     // do something if its first time publish
   } else {
     // Do something if its update
   }
}

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

Example to ialocin answer with "update" paremeter:

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

   if($update == false) {
     // do something if its first time publish
   } else {
     // Do something if its update
   }
}

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

Vouspouvez utiliser le hook d'actionpre_post_updatepour le code demise àjouret save_postpour lenouveau codepostal.Celafonctionne avant lamise àjour d'un article.

You can use pre_post_update action hook for the update code and save_post for the new post code. It works before a post is updated.

Comme l'a laisséentendre Darshan Thanki (et Stephen Harris aexpliquéplusen détail),vouspouvez utiliser pre_post_update à votre avantage.

 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 raisonpour laquellej'ai utilisé desglobalsestparce que function is_new_post() use ( &$new_post )n'estpas valideen PHP (choquant ...) donctirer cette variable dans laportée de lafonctionnene fonctionnepas - d'où leglobal.

Notez que celane peut vraiment être utilisé demanièrefiable que dans/après l'événement save_post (ce quiestgénéralement suffisant,dumoinspour ce quenousen faisons).

As Darshan Thanki hinted (and Stephen Harris further elaborated), you can use pre_post_update to your advantage.

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

The reason why I used globals is because function is_new_post() use ( &$new_post ) is not valid in PHP (shocking...) so pulling in that variable into the function scope doesn't work -- hence the global.

Note that this can really only reliably be used within/after the save_post event (which is usually sufficient, at least for what we're doing with it).

Lorsque save_postest déclenché,toutes lesinformations sur cemessage sont déjà disponibles,doncen théorie,vouspouvez utiliser

 function f4553265_check_post() {

    if (!get_posts($post_id)) {
    // if this is a new post get_posts($post_id) should return null
    } else {
    // $post_id already exists on the database
    }
}
add_action('save_post','f4553265_check_post');
 

celan'apas ététesté,cependant.=)

When save_post is triggered, all information about that post is already available, so in theory you could use

function f4553265_check_post() {

    if (!get_posts($post_id)) {
    // if this is a new post get_posts($post_id) should return null
    } else {
    // $post_id already exists on the database
    }
}
add_action('save_post','f4553265_check_post');

this is untested, though. =)

Une autre approche qui utilise unefonctionintégréeet aucun ajout à labase de donnéesimpliquerait get_post_status().

 $post_status = get_post_status();
if ( $post_status != 'draft' ) {
    //draft
} else { 
    //not a draft: can be published, pending, etc. 
}
 

Notez cependant que celapourraitne pas être approprié si vousprévoyez de redéfinir ultérieurement le statut sur "brouillon" - vosinstructions seront répétées laprochainefois que vousmettrez àjour lemessage. Selon le contexte,vous voudrezpeut-être considérer les différentes chaînes quipeuvent être retournéespar get_post_status()pour construire un scénarioplus approprié.

Voir Codexpour get_post_status () et État dumessage

Les valeurspossibles sont:

• 'publier' - Un article ou unepagepublié
• 'en attente' - lemessageesten attente d'examen
• "brouillon" - unmessage à l'étatbrouillon
• "brouillon automatique" - unmessagenouvellement créé,sans contenu
• 'future' - un article àpublier dans lefutur
• 'privé' -non visiblepour les utilisateurs quine sontpas connectés
• 'inherit' - une révision. voirget_children.
• 'corbeille' - lemessageest dans la corbeille. ajouté avec la version 2.9.

Another approach that uses a built-in function and no addition to the database would involve get_post_status().

$post_status = get_post_status();
if ( $post_status != 'draft' ) {
    //draft
} else { 
    //not a draft: can be published, pending, etc. 
}

Note however that it might not be appropriate if you plan to later set the status back to "draft" – your instructions would be repeated the next time you will update the post. Depending on the context, you might want to consider the various strings that can be returned by get_post_status() to build a more appropriate scenario.

See Codex for get_post_status() and Post Status

Possible values are:

• 'publish' - A published post or page
• 'pending' - post is pending review
• 'draft' - a post in draft status
• 'auto-draft' - a newly created post, with no content
• 'future' - a post to publish in the future
• 'private' - not visible to users who are not logged in
• 'inherit' - a revision. see get_children.
• 'trash' - post is in trashbin. added with Version 2.9.

Je viens de rencontrer le save_post sur lesnouveautéset lesmises àjour. Après avoir lu le code sourcepour comprendre leflux. J'aitrouvé que laméthode suivantepourrait être utile. Puisqu'iln'estpasencorementionné auparavant. Voyez si celaest utile à quelqu'un. (Letestest le Core 5.3.3)

Leflux depost-créationest approximativement:

1. Après avoir appuyé sur Ajouter unnouveau (message)
2. $post=get_default_post_to_edit ($post_type,true); sera appelé où
3. get_default_post_to_edit () reçoit l'argument $ create_in_db=true
4. afin que wp_insert_post () soitimmédiatement appelé,unmessage auto-draftesten cours de création,même s'iln'estpasenregistré,chaquefois que vous cliquez sur Add New,un auto-draftest créé
5. $ updateesttoujours vraipour Publish. Ainsi,lorsque vouspubliez unnouveaumessage,c'est vrai.

En comparant l'objet $ _POSTpour unnouvel articleet mettre àjour l'article ou republier l'article,laprincipale différenceest la valeur _wp_http_referer,lenouvel articleest /wp-admin/post-new.php

Hypothèse: on suppose que l'articleestpublié/ajouté àpartir de l'interface utilisateur. Si celaestfaitpar un autremécanisme,codepersonnalisé,la vérificationestnécessairepour ajuster.

 add_action( 'save_post', 'test_save_post_check', 0, 3 );
function test_save_post_check( $post_ID, $post, $update ) {
    // other tests + this
    // checking the 'post-new' position from the '_wp_http_referer'
    if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ) {
        // new
    } else {
        // update
    }
}
 

I have just encountered the save_post about new and update. After reading the source code to understand the flow. I found that the following method might be useful. Since it is not yet mentioned before. See if it is useful to anyone. (The test is Core 5.3.3)

The Post creation flow is approximately:

1. After pressing Add New (Post)
2. $post = get_default_post_to_edit( $post_type, true ); will be called where
3. get_default_post_to_edit() receive argument $create_in_db = true
4. so wp_insert_post() is immediately being called, auto-draft post is being created, even it is not saved, every time clicking Add New, an auto-draft is created
5. $update is always true for Publish. So when Publish a new post, it is true.

By comparing the $_POST object for new post and update post or republish post, the prominent difference is value _wp_http_referer, the new post is /wp-admin/post-new.php

Assumption: assumed the post is published/added from UI. If it is done by other mechanism, custom code, the checking is needed to adjust.

add_action( 'save_post', 'test_save_post_check', 0, 3 );
function test_save_post_check( $post_ID, $post, $update ) {
    // other tests + this
    // checking the 'post-new' position from the '_wp_http_referer'
    if( strpos( wp_get_raw_referer(), 'post-new' ) > 0 ) {
        // new
    } else {
        // update
    }
}