Cea mai bună colecție de cod pentru fișierul tău 'functions.php'

Includere tipuri personalizate de postări în panoul de administrare "Right Now"

Acest cod va include tipurile tale personalizate de postări și numărul de postări pentru fiecare tip în widget-ul "Right Now" din panoul de control.

// ADAUGĂ TIPURI PERSONALIZATE DE POSTĂRI ÎN WIDGET-UL 'RIGHT NOW' DIN PANOU
function wph_right_now_content_table_end() {
 $args = array(
  'public' => true ,
  'show_ui' => true ,
  '_builtin' => false
 );
 $output = 'object';
 $operator = 'and';
 
 $post_types = get_post_types( $args , $output , $operator );
 foreach( $post_types as $post_type ) {
  $num_posts = wp_count_posts( $post_type->name );
  $num = number_format_i18n( $num_posts->publish );
  $text = _n( $post_type->labels->singular_name, $post_type->labels->name , intval( $num_posts->publish ) );
  if ( current_user_can( 'edit_posts' ) ) {
   $num = "<a href='edit.php?post_type=$post_type->name'>$num</a>";
   $text = "<a href='edit.php?post_type=$post_type->name'>$text</a>";
  }
  echo '<tr><td class="first b b-' . $post_type->name . '">' . $num . '</td>';
  echo '<td class="t ' . $post_type->name . '">' . $text . '</td></tr>';
 }
 $taxonomies = get_taxonomies( $args , $output , $operator ); 
 foreach( $taxonomies as $taxonomy ) {
  $num_terms  = wp_count_terms( $taxonomy->name );
  $num = number_format_i18n( $num_terms );
  $text = _n( $taxonomy->labels->singular_name, $taxonomy->labels->name , intval( $num_terms ));
  if ( current_user_can( 'manage_categories' ) ) {
   $num = "<a href='edit-tags.php?taxonomy=$taxonomy->name'>$num</a>";
   $text = "<a href='edit-tags.php?taxonomy=$taxonomy->name'>$text</a>";
  }
  echo '<tr><td class="first b b-' . $taxonomy->name . '">' . $num . '</td>';
  echo '<td class="t ' . $taxonomy->name . '">' . $text . '</td></tr>';
 }
}
add_action( 'right_now_content_table_end' , 'wph_right_now_content_table_end' );

Adaugă un formular de căutare Codex în antetul panoului de administrare

Acesta este un mod simplu de a adăuga un formular de căutare Codex în antetul panoului de administrare, în partea dreaptă sus, lângă meniul rapid derulant.

/**
 * ADAUGĂ FORMULAR DE CĂUTARE WP CODEX ÎN ANTETUL PANOULUI DE ADMINISTRARE
 */
function wp_codex_search_form() {
    echo '<form target="_blank" method="get" action="http://wordpress.org/search/do-search.php" class="alignright" style="margin: 11px 5px 0;">
        <input type="text" onblur="this.value=(this.value==\'\') ? \'Caută în Codex\' : this.value;" onfocus="this.value=(this.value==\'Caută în Codex\') ? \'\' : this.value;" maxlength="150" value="Caută în Codex" name="search" class="text"> <input type="submit" value="Mergi" class="button" />
    </form>';
}

if( current_user_can( 'manage_plugins' )) {
// Numărul 11 trebuie să fie 10 pentru ca această funcție să funcționeze!
    add_filter( 'in_admin_header', 'wp_codex_search_form', 11 );
}

Nouă Coloană în Biblioteca Media pentru Reatasarea Imaginilor

Acest cod adaugă o nouă coloană în pagina Biblioteca Media care permite reatasarea imaginilor

add_filter("manage_upload_columns", 'upload_columns');
add_action("manage_media_custom_column", 'media_custom_columns', 0, 2);

function upload_columns($columns) {
    unset($columns['parent']);
    $columns['better_parent'] = "Părinte";
    return $columns;
}
function media_custom_columns($column_name, $id) {
    $post = get_post($id);
    if($column_name != 'better_parent')
        return;
        if ( $post->post_parent > 0 ) {
            if ( get_post($post->post_parent) ) {
                $title =_draft_or_post_title($post->post_parent);
            }
            ?>
            <strong><a href="<?php echo get_edit_post_link( $post->post_parent ); ?>"><?php echo $title ?></a></strong>, <?php echo get_the_time(__('Y/m/d')); ?>
            <br />
            <a class="hide-if-no-js" onclick="findPosts.open('media[]','<?php echo $post->ID ?>');return false;" href="#the-list"><?php _e('Reatașează'); ?></a>
            <?php
        } else {
            ?>
            <?php _e('(Neatasat)'); ?><br />
            <a class="hide-if-no-js" onclick="findPosts.open('media[]','<?php echo $post->ID ?>');return false;" href="#the-list"><?php _e('Atașează'); ?></a>
            <?php
        }
}

Buclă personalizată cu temă folosind shortcode-uri

Argumentele sunt aceleași ca cele din query_posts. Conținutul încadrat între tag-ul query este șablonul.

add_shortcode('query', 'shortcode_query');

function shortcode_query($atts, $content){
  extract(shortcode_atts(array( // câteva valori implicite
   'posts_per_page' => '10',
   'caller_get_posts' => 1,
   'post__not_in' => get_option('sticky_posts'),
  ), $atts));

  global $post;

  $posts = new WP_Query($atts);
  $output = '';
  if ($posts->have_posts())
    while ($posts->have_posts()):
      $posts->the_post();

      // aceste argumente vor fi disponibile din interiorul $content
      $parameters = array(
        'PERMALINK' => get_permalink(),
        'TITLE' => get_the_title(),
        'CONTENT' => get_the_content(),
        'COMMENT_COUNT' => $post->comment_count,
        'CATEGORIES' => get_the_category_list(', '),
        // adaugă aici mai multe...
      );

      $finds = $replaces = array();
      foreach($parameters as $find => $replace):
        $finds[] = '{'.$find.'}';
        $replaces[] = $replace;
      endforeach;
      $output .= str_replace($finds, $replaces, $content);

    endwhile;
  else
    return; // nu s-au găsit postări

  wp_reset_query();
  return html_entity_decode($output);
}

Utilizare:

[query post_type=page posts_per_page=5]
Listare câteva pagini:    
<h5>{TITLE}</h5>
<div>{CONTENT}</div>
<p><a href="{PERMALINK}">{COMMENT_COUNT} comentarii</a></p>
[/query]

(va face o interogare pentru 5 pagini)

Inserarea de widget-uri preconfigurate oriunde folosind shortcode-uri

(unele idei de la http://webdesign.anmari.com/shortcode-any-widget)

add_action('widgets_init', 'create_arbitrary_sidebar');
function create_arbitrary_sidebar(){
  register_sidebar(array(
    'name' => __('Widget-uri Arbitrare'),
    'id' => 'arbitrary',
    'description' => sprintf(__('Widget-urile din această zonă pot fi adăugate în postări/pagini folosind shortcode-urile %1$s sau %2$s.'), '[widget ID]', '[widget Nume]'),
    'before_widget' => '<div class="block"><div class="block-content block-%2$s clear-block" id="instance-%1$s">',
    'after_widget' => '</div></div>',
    'before_title' => '<h3 class="title">',
    'after_title' => '</h3>'
   ));
}

add_action('in_widget_form', 'widget_shortcodes_info', 10, 3);
function widget_shortcodes_info($widget, $return, $instance){
  if(!is_numeric($widget->number)) return; // bug wp-save :( widget-ul trebuie salvat mai întâi...

  global $wp_registered_widgets;

  // obține widget-urile active din toate barele laterale
  $sidebars_widgets = wp_get_sidebars_widgets();

  // pregătește potrivirile
  $matches = array();
  foreach($wp_registered_widgets as $i => $w)
    if($w['name'] == $widget->name) $matches[] = $w['id'];

  // află poziția widget-ului (numărul)
  $number = 0;
  $is_arbitrary = false;
  if(!empty($sidebars_widgets['arbitrary']))
    foreach($sidebars_widgets['arbitrary'] as $i => $value):
      if(in_array($value, $matches) && !$is_arbitrary) $number = $number +1;
      if($value == $widget->id) $is_arbitrary = true;
    endforeach;

  echo '<div style="background:#eee; padding: 5px;">Pentru a include acest widget în postările sau paginile tale, folosește unul dintre următoarele shortcode-uri: <br />';
  echo '<code>[widget '.substr(md5($widget->id), 0, 8).']</code> <br /> <code>[widget "'.$widget->name.'"'.(($number > 1) ? ' number='.$number : null).']</code></div>';
}

add_shortcode('widget', 'shortcode_widget');
function shortcode_widget($atts){
  global $wp_registered_widgets, $wp_registered_sidebars;
  extract(shortcode_atts(array(
    'number' => false,        // luat în considerare doar dacă primul argument este "Nume Widget" (nu ID-ul hash-uit)
    'title' => true,          // afișează titluri?
    'area' => 'arbitrary'     // bara laterală de căutat
  ), $atts));

  // obține primul parametru (presupunând că este ID-ul sau numele widget-ului țintă)
  if (!empty($atts[0])) $widget = esc_attr($atts[0]); else return;

  $sidebar = esc_attr($area);
  $number = intval($number);

  $callback = false;
  $possible_matches = array();
  $sidebars_widgets = wp_get_sidebars_widgets();
  if((empty($sidebars_widgets[$sidebar]) || empty($wp_registered_widgets)) && (current_user_can('edit_themes')))
    return "nu există widget-uri active valide în {$sidebar}";

  // presupunând că primim ID-ul hash-uit md5
  foreach ($wp_registered_widgets as $i => $w)
    if ($widget == substr(md5($w['id']), 0, 8)):
      $callback = ($w['callback']);
      $widget = $w['id']; // ID-ul real al widget-ului

    // compară și numele widget-urilor și construiește un array cu posibilele potriviri
    // (folosit mai târziu dacă potrivirea ID eșuează)
    elseif($widget == $w['name'])):
      $possible_matches[] = $w['id'];

    endif;

  // nimic găsit, presupunem că este "Nume Widget".
  if(!$callback):
    $valid_matches = array();
    foreach($sidebars_widgets[$sidebar] as $i => $w)
      foreach($possible_matches as $id) if($id == $w) $valid_matches[] = $w;

    if(!empty($valid_matches)) $widget = $number ? $valid_matches[$number-1] : $widget = $valid_matches[0];
    if($widget && isset($wp_registered_widgets[$widget]['callback'])) $callback = $wp_registered_widgets[$widget]['callback'];
  endif;

  // ura. l-am găsit
  if($callback):
    ob_start();

    $params = array_merge(array(array_merge($wp_registered_sidebars[$sidebar], array('widget_id' => $widget, 'widget_name' => $wp_registered_widgets[$widget]['name']))), (array)$wp_registered_widgets[$widget]['params']);

    $classname_ = '';
    foreach ((array)$wp_registered_widgets[$widget]['classname'] as $cn)
      if (is_string($cn)) $classname_ .= '_'.$cn; elseif (is_object($cn)) $classname_ .= '_'.get_class($cn);
    $classname_ = ltrim($classname_, '_');
    $params[0]['before_widget'] = sprintf($params[0]['before_widget'], $widget, $classname_);
    $params = apply_filters('dynamic_sidebar_params', $params);

    if (is_callable($callback)) call_user_func_array($callback, $params);
    $output = ob_get_clean();

    // elimină h3 dacă title = false
    if(!$title) $output = preg_replace('#<h3 class="title">(.*?)</h3>#', '', $output);
    return $output;
  else:
   return "instanță widget negăsită: ".esc_attr($atts[0]);
  endif;
}

Utilizare:

Plasează un widget în bara laterală "widget-uri arbitrare", salvează-l și vei primi shortcode-urile :)

Obținerea unei valori de câmp personalizat prin shortcode-uri

add_shortcode('field', 'shortcode_field');

function shortcode_field($atts){
  extract(shortcode_atts(array(
   'post_id' => NULL,
  ), $atts));

  if(!isset($atts[0])) return;
  $field = esc_attr($atts[0]);

  global $post;
  $post_id = (NULL === $post_id) ? $post->ID : $post_id;

  return get_post_meta($post_id, $field, true);
}

Utilizare:

• [field "cheia_mea"]
• [field "cheia_mea" post_id=1]

Obținerea TinyURL a unui link prin shortcode-uri

add_shortcode('tinyurl', 'shortcode_tinyurl'); 

function shortcode_tinyurl($atts){
  extract(shortcode_atts(array(
   'url' => get_permalink(),
   'title' => '',
   'rel' => 'nofollow'
  ), $atts));
  if(!$title) $title = $url;

  if (FALSE === ($cache = get_transient('tinyurl_'+md5($url)))):
    $cache = wp_remote_retrieve_body(wp_remote_get('http://tinyurl.com/api-create.php?url='.$url));

    set_transient('tinyurl_'+md5($url), $cache, 60*60*24); // cache de 1 zi, poate fi mărit
  endif;

  return '<a href="'.esc_url($cache).'" rel="'.esc_attr($rel).'">'.esc_attr($title).'</a>';
}

Utilizare:

• [tinyurl]
• [tinyurl url="http://google.com" title="google"]

Setează Editorul Implicit la WYSIWYG sau HTML

function my_default_editor() {
    $r = 'tinymce'; // html sau tinymce
    return $r;
}
add_filter( 'wp_default_editor', 'my_default_editor' );

Iată cum poți elimina Editorul HTML

jQuery(document).ready(function($) {
$("#edButtonHTML").remove();
});

ACTUALIZAT iată o altă metodă pentru a seta editorul implicit la HTML

add_filter('wp_default_editor', create_function('', 'return "html";'));

Elimină MetaBox-ul Autor/Opțiuni și Mută în MetaBox-ul Publicare

Testat pe: Wordpress 3.0.1

Unul dintre lucrurile care mă enervează este o interfață aglomerată în Administrarea WordPress. Unul dintre elementele pe care le configurez acum întotdeauna de la început în fișierul functions.php este eliminarea MetaBox-ului Autor și a Opțiunilor de Ecran, apoi adăugarea opțiunii în MetaBox-ul de Publicare. În opinia mea, acest lucru are sens și menține lucrurile organizate. De asemenea, respectă permisiunile aplicabile.

Pentru a realiza acest lucru, copiați și lipiți următorul cod în fișierul functions.php.

Dacă considerați că există o metodă mai bună de a face acest lucru, sugerați.

NOTĂ: CODUL A FOST ACTUALIZAT PENTRU A REMEDIA O PROBLEMĂ DE CODARE

// MUTĂ METABOX-UL AUTOR ÎN METABOX-UL PUBLICARE  
add_action( 'admin_menu', 'remove_author_metabox' );  
add_action( 'post_submitbox_misc_actions', 'move_author_to_publish_metabox' );  
function remove_author_metabox() {  
    remove_meta_box( 'authordiv', 'post', 'normal' );  
}  
function move_author_to_publish_metabox() {  
    global $post_ID;  
    $post = get_post( $post_ID );  
    echo '<div id="author" class="misc-pub-section" style="border-top-style:solid; border-top-width:1px; border-top-color:#EEEEEE; border-bottom-width:0px;">Autor: ';  
    post_author_meta_box( $post );  
    echo '</div>';  
}  

Determină Rapid Detaliile Serverului și ale Mediului

Dacă ai mai multe servere și mai multe medii, cum ar fi dezvoltare, QA și producție, acest lucru poate fi foarte util.

Pentru sistemele mele, mediul este determinat de primele 3 litere ale numelui gazdei, dar acest lucru poate fi ușor modificat pentru a se potrivi nevoilor tale.

add_action( 'admin_notices', 'report_environment_status', 3 );

// Raportează detaliile serverului și ale mediului
function report_environment_status() {
    $server = php_uname('n');
    switch (strtolower(substr($server,0,3))) {
        case 'pXX':
            $msg = "PRODUCȚIE";
            break;
        case 'qXX':
            $msg = "QA";
            break;
        case 'dXX':
            $msg = "DEZVOLTARE";
            break;
        default :
            $msg = 'NECUNOSCUT';
    }
    echo "<div id='update-nag'>";
    echo "<b>Ești în mediul $msg. (Server: $server)</b>";
    echo "</div>";
}

Acest lucru m-a salvat de multe ori de la a face actualizări în mediul greșit.

Poți să transformi acest cod într-un plugin și să-l activezi în rețea, astfel încât toate site-urile să primească notificarea.

Rezolvat: Eliminarea casetelor meta implicite din WordPress

Acest lucru era foarte util, dar avea câteva erori

// ELIMINĂ CASETELE META DIN ECRANUL IMPLICIT AL POSTĂRILOR
function remove_default_post_screen_metaboxes() {
 remove_meta_box( 'postcustom','post','normal' ); // Caseta meta Câmpuri Personalizate
 remove_meta_box( 'postexcerpt','post','normal' ); // Caseta meta Rezumat
 remove_meta_box( 'commentstatusdiv','post','normal' ); // Caseta meta Comentarii
 remove_meta_box( 'trackbacksdiv','post','normal' ); // Caseta meta Trackback-uri
 remove_meta_box( 'slugdiv','post','normal' ); // Caseta meta Slug
 remove_meta_box( 'authordiv','post','normal' ); // Caseta meta Autor
}
add_action('admin_menu','remove_default_post_screen_metaboxes');


// ELIMINĂ CASETELE META DIN ECRANUL IMPLICIT AL PAGINILOR
function remove_default_page_screen_metaboxes() {
 global $post_type;
 remove_meta_box( 'postcustom','page','normal' ); // Caseta meta Câmpuri Personalizate
 remove_meta_box( 'postexcerpt','page','normal' ); // Caseta meta Rezumat
 remove_meta_box( 'commentstatusdiv','page','normal' ); // Caseta meta Comentarii
 remove_meta_box('commentsdiv','page','normal'); // Comentarii
 remove_meta_box( 'trackbacksdiv','page','normal' ); // Caseta meta Trackback-uri
 remove_meta_box( 'slugdiv','page','normal' ); // Caseta meta Slug
 remove_meta_box( 'authordiv','page','normal' ); // Caseta meta Autor
}
add_action('admin_menu','remove_default_page_screen_metaboxes');

Extinderea perioadei de auto deconectare

Testat pe: WordPress 3.0.1

Folosind codul de mai jos, puteți crește timpul în care cookie-urile sunt păstrate și, prin urmare, utilizatorii autentificați rămân conectați mai mult timp:

function keep_me_logged_in_for_1_year( $expirein ) {
   return 31556926; // 1 an în secunde
}
add_filter( 'auth_cookie_expiration', 'keep_me_logged_in_for_1_year' );

Adăugarea unui link "Setări" pentru plugin-uri pe pagina de listare a plugin-urilor

Configurarea linkului "Setări" pentru plugin-uri pe pagina de plugin-uri în interfața de administrare WordPress, ușor de utilizat pentru a accesa rapid setările (codul include și o soluție pentru versiunile de WordPress mai mici de 2.9)

// definiții plugin
define( 'FB_BASENAME', plugin_basename( __FILE__ ) );
define( 'FB_BASEFOLDER', plugin_basename( dirname( __FILE__ ) ) );
define( 'FB_FILENAME', str_replace( FB_BASEFOLDER.'/', '', plugin_basename(__FILE__) ) );
function filter_plugin_meta($links, $file) {
  /* creare link */
  if ( $file == FB_BASENAME ) {
    array_unshift(
      $links,
      sprintf( '<a href="options-general.php?page=%s">%s</a>', FB_FILENAME, __('Setări') )
    );
  }
  return $links;
}

global $wp_version;
if ( version_compare( $wp_version, '2.7alpha', '>' ) ) {
    add_filter( 'plugin_action_links_' . FB_WM_BASENAME, 'filter_plugin_meta', 10, 2);
} else {
    add_filter( 'plugin_action_links', 'filter_plugin_meta', 10, 2 );
}

Eliminarea Legăturilor Automate ale URL-urilor în Comentariile WordPress

remove_filter('comment_text', 'make_clickable', 9);

Adăugare filtru pentru șabloane de pagini în lista de pagini

Testat pe: WP 3.1

Adaugă un filtru pentru șabloanele de pagini în lista de pagini, permițând vizualizarea unei liste de pagini care au un anumit șablon asociat.

class Page_Template_Filter {
    private $templates = array();
    public function __construct() {
        // Dacă nu suntem în zona de administrare sau utilizatorul curent nu poate edita pagini, ieșim
        if( !is_admin() || !current_user_can('edit_pages') )
            return;
        add_action( 'parse_query',           array( $this, 'pt_parse_query' ) );
        add_action( 'restrict_manage_posts', array( $this, 'pt_restrict_manage_posts' ) );
    }
    public function pt_parse_query( $query ) {
        global $pagenow, $post_type;
        if( 'edit.php' != $pagenow )
            return;

        switch( $post_type ) {
            case 'post':

            break;
            case 'page':
                $this->templates = get_page_templates();

                if( empty( $this->templates ) )
                    return;

                if( !$this->is_set_template() )
                    return;

                $meta_group = array( 'key' => '_wp_page_template', 'value' => $this->get_template() );
                set_query_var( 'meta_query', array( $meta_group ) );
            break;
        }
    }
    public function pt_restrict_manage_posts() {
        if( empty( $this->templates ) )
            return;
        $this->template_dropdown();
    }
    private function get_template() {
        if( $this->is_set_template() )
            foreach( $this->templates as $template ) {
                if( $template != $_GET['page_template'] )
                    continue;
                return $template;
            }
        return '';
    }
    private function is_set_template() {
        return (bool) ( isset( $_GET['page_template'] ) && ( in_array( $_GET['page_template'], $this->templates ) ) );
    }
    private function template_dropdown() {
        ?>
        <select name="page_template" id="page_template">
            <option value=""> - fără șablon - </option>
            <?php foreach( $this->templates as $name => $file ): ?>
            <option value="<?php echo $file; ?>"<?php selected( $this->get_template() == $file ); ?>><?php _e( $name ); ?></option>
            <?php endforeach;?>
        </select>
        <?php 
    }
}

add_action('admin_init', 'load_ptf');
function load_ptf() {
    $Page_Template_Filter = new Page_Template_Filter;
}

Necesită cel puțin versiunea 3.1 pentru a funcționa, deși meta_query poate fi înlocuit cu meta_key și meta_value pentru versiunea 3.0.

Afisează doar postările și fișierele media ale autorului conectat & corectează numărul de postări/media din barele de filtrare.

Testat pe: Wordpress 3.4.1

În mod implicit, WordPress permite Autorilor să vadă titlurile postărilor altor utilizatori, ciorne nepublicate și toate fișierele media, chiar dacă nu le pot edita.

Folosește acest cod pentru a permite afișarea doar a postărilor și fișierelor media ale autorului care este conectat în prezent.

Spre deosebire de alte soluții, acest cod corectează și numărul de postări/media din barele de filtrare (Toate|Publicate|Ciorne|În așteptare|Gunoi; Toate|Imagini|Video|Neatașate).

// Afișează doar postările și fișierele media ale autorului conectat
add_action('pre_get_posts', 'query_set_only_author' );
function query_set_only_author( $wp_query ) {
    global $current_user;
    if( is_admin() && !current_user_can('edit_others_posts') ) {
        $wp_query->set( 'author', $current_user->ID );
        add_filter('views_edit-post', 'fix_post_counts');
        add_filter('views_upload', 'fix_media_counts');
    }
}

// Corectează numărul de postări
function fix_post_counts($views) {
    global $current_user, $wp_query;
    unset($views['mine']);
    $types = array(
        array( 'status' =>  NULL ),
        array( 'status' => 'publish' ),
        array( 'status' => 'draft' ),
        array( 'status' => 'pending' ),
        array( 'status' => 'trash' )
    );
    foreach( $types as $type ) {
        $query = array(
            'author'      => $current_user->ID,
            'post_type'   => 'post',
            'post_status' => $type['status']
        );
        $result = new WP_Query($query);
        if( $type['status'] == NULL ):
            $class = ($wp_query->query_vars['post_status'] == NULL) ? ' class="current"' : '';
            $views['all'] = sprintf(__('<a href="%s"'. $class .'>Toate <span class="count">(%d)</span></a>', 'all'),
                admin_url('edit.php?post_type=post'),
                $result->found_posts);
        elseif( $type['status'] == 'publish' ):
            $class = ($wp_query->query_vars['post_status'] == 'publish') ? ' class="current"' : '';
            $views['publish'] = sprintf(__('<a href="%s"'. $class .'>Publicate <span class="count">(%d)</span></a>', 'publish'),
                admin_url('edit.php?post_status=publish&post_type=post'),
                $result->found_posts);
        elseif( $type['status'] == 'draft' ):
            $class = ($wp_query->query_vars['post_status'] == 'draft') ? ' class="current"' : '';
            $views['draft'] = sprintf(__('<a href="%s"'. $class .'>Ciornă'. ((sizeof($result->posts) > 1) ? "e" : "") .' <span class="count">(%d)</span></a>', 'draft'),
                admin_url('edit.php?post_status=draft&post_type=post'),
                $result->found_posts);
        elseif( $type['status'] == 'pending' ):
            $class = ($wp_query->query_vars['post_status'] == 'pending') ? ' class="current"' : '';
            $views['pending'] = sprintf(__('<a href="%s"'. $class .'>În așteptare <span class="count">(%d)</span></a>', 'pending'),
                admin_url('edit.php?post_status=pending&post_type=post'),
                $result->found_posts);
        elseif( $type['status'] == 'trash' ):
            $class = ($wp_query->query_vars['post_status'] == 'trash') ? ' class="current"' : '';
            $views['trash'] = sprintf(__('<a href="%s"'. $class .'>Gunoi <span class="count">(%d)</span></a>', 'trash'),
                admin_url('edit.php?post_status=trash&post_type=post'),
                $result->found_posts);
        endif;
    }
    return $views;
}

// Corectează numărul de fișiere media
function fix_media_counts($views) {
    global $wpdb, $current_user, $post_mime_types, $avail_post_mime_types;
    $views = array();
    $_num_posts = array();
    $count = $wpdb->get_results( "
        SELECT post_mime_type, COUNT( * ) AS num_posts 
        FROM $wpdb->posts 
        WHERE post_type = 'attachment' 
        AND post_author = $current_user->ID 
        AND post_status != 'trash' 
        GROUP BY post_mime_type
    ", ARRAY_A );
    foreach( $count as $row )
        $_num_posts[$row['post_mime_type']] = $row['num_posts'];
    $_total_posts = array_sum($_num_posts);
    $detached = isset( $_REQUEST['detached'] ) || isset( $_REQUEST['find_detached'] );
    if ( !isset( $total_orphans ) )
        $total_orphans = $wpdb->get_var("
            SELECT COUNT( * ) 
            FROM $wpdb->posts 
            WHERE post_type = 'attachment' 
            AND post_author = $current_user->ID 
            AND post_status != 'trash' 
            AND post_parent < 1
        ");
    $matches = wp_match_mime_types(array_keys($post_mime_types), array_keys($_num_posts));
    foreach ( $matches as $type => $reals )
        foreach ( $reals as $real )
            $num_posts[$type] = ( isset( $num_posts[$type] ) ) ? $num_posts[$type] + $_num_posts[$real] : $_num_posts[$real];
    $class = ( empty($_GET['post_mime_type']) && !$detached && !isset($_GET['status']) ) ? ' class="current"' : '';
    $views['all'] = "<a href='upload.php'$class>" . sprintf( __('Toate <span class="count">(%s)</span>', 'fișiere încărcate' ), number_format_i18n( $_total_posts )) . '</a>';
    foreach ( $post_mime_types as $mime_type => $label ) {
        $class = '';
        if ( !wp_match_mime_types($mime_type, $avail_post_mime_types) )
            continue;
        if ( !empty($_GET['post_mime_type']) && wp_match_mime_types($mime_type, $_GET['post_mime_type']) )
            $class = ' class="current"';
        if ( !empty( $num_posts[$mime_type] ) )
            $views[$mime_type] = "<a href='upload.php?post_mime_type=$mime_type'$class>" . sprintf( translate_nooped_plural( $label[2], $num_posts[$mime_type] ), $num_posts[$mime_type] ) . '</a>';
    }
    $views['detached'] = '<a href="upload.php?detached=1"' . ( $detached ? ' class="current"' : '' ) . '>' . sprintf( __( 'Neatașate <span class="count">(%s)</span>', 'fișiere detașate' ), $total_orphans ) . '</a>';
    return $views;
}

Elimină XML-RPC când nu este folosit pentru o îmbunătățire a performanței

Testat pe: Wordpress 3.0.1

WordPress utilizează o operațiune CURL pentru a testa capacitatea SSL pentru XML-RPC. Dacă folosești XML-RPC dar nu-l utilizezi, poți elimina filtrul. Aceasta este o mică îmbunătățire a performanței (deoarece practic WP face un GET prin cURL pe URL-ul https și fie 1) primește un mesaj de respingere, fie 2) depășește timpul de așteptare, iar acest lucru poate dura până la 5 secunde), dar în cazul nostru a prevenit chiar un timeout al gateway-ului, unde un proxy depășea timpul de așteptare înainte ca operațiunea cURL GET să se termine, făcând XML-RPC inutilizabil.

// Previne WordPress să testeze capacitatea SSL pe domain.com/xmlrpc.php?rsd
remove_filter('atom_service_url','atom_service_url_filter');

Colecție de modificări rapide în functions.php

Am și eu câteva ajustări minunate în functions.php. Le-am găsit pe majoritatea căutându-le de-a lungul anilor.

Sfârșitul Excerpt

function new_excerpt_more($more) {
    return '...';
}
add_filter('excerpt_more', 'new_excerpt_more');

Înlocuire Logo WP Admin

function new_admin_logo() {
  echo '<style type="text/css">#header-logo { background-image: url('.get_bloginfo('template_directory').'/images/admin_logo.png) !important; }</style>';
}
add_action('admin_head', 'new_admin_logo');

Favicon Personalizat pentru WP-Admin

function admin_favicon() {
 echo '<link rel="shortcut icon" type="image/x-icon" href="' . get_bloginfo('template_directory') . '/images/favicon.ico" />';
}
add_action( 'admin_head', 'admin_favicon' );

Subsol Personalizat pentru Admin

function custom_admin_footer() {
echo 'Bine ați venit pe blogul meu! Fără link-uri de documentare!';
}
add_filter('admin_footer_text', 'custom_admin_footer');

Obține toate câmpurile personalizate global

function get_custom_field($key, $echo = FALSE) {
    global $post;
    $custom_field = get_post_meta( $post->ID, $key, true );
    if ( $echo == false ) 
        return $custom_field;
    echo $custom_field;
}

Apoi apelează câmpul cu o singură linie

<?php get_custom_field('nume-camp-personalizat', TRUE); ?>

Returnează numărul de comentarii

Aceasta este similar cu count_user_posts(), dar returnează numărul de comentarii în loc de postări:

function count_user_comments($id) {
global $wpdb;
$users = $wpdb->get_var("
        SELECT COUNT( * ) AS total
        FROM $wpdb->comments
        WHERE comment_approved = 1 
        AND user_id = $id");
return $users;
}

Mai mult: Numără postările utilizatorului (inclusiv tipurile personalizate de postări) sau comentariile:

function atom_count($user_id, $what_to_count = 'post') {
  global $wpdb;    
  $where = $what_to_count == 'comment' ? "WHERE comment_approved = 1 AND user_id = {$user_id}" : get_posts_by_author_sql($what_to_count, TRUE, $user_id);
  $from = "FROM ".(($what_to_count == 'comment') ? $wpdb->comments : $wpdb->posts);    
  $count = $wpdb->get_var($wpdb->prepare("SELECT COUNT(*) {$from} {$where}"));
  return $count;
}

Exemple de utilizare:

<?php echo atom_count(1, 'movie'); // afișează numărul de postări de tip 'movie' ?>

<?php echo atom_count(1, 'comment'); // afișează numărul de comentarii ?>

Activează oEmbed în Widget-urile Text/HTML

add_filter( 'widget_text', array( $wp_embed, 'run_shortcode' ), 8 );
add_filter( 'widget_text', array( $wp_embed, 'autoembed'), 8 );

Folosesc acest cod pentru widget-uri cu videoclipuri YouTube și conținut Flickr.

Numărătoare Cuvinte Articol

Testat pe: Wordpress 3.0.1

(Extras inițial din modulul Post Word Count de Nick Momrick)

Adaugă un contor al totalului de cuvinte publicate în partea de jos a casetei "Right Now" din panoul de administrare. Util dacă folosești blogul ca mediu pentru ceva de genul NaNoWriMo sau dacă vrei să ții evidența cât de prolific ai devenit în scris.

function post_word_count() {
    $count = 0;
    $posts = get_posts( array(
        'numberposts' => -1,
        'post_type' => array( 'post', 'page' )
    ));
    foreach( $posts as $post ) {
        $count += str_word_count( strip_tags( get_post_field( 'post_content', $post->ID )));
    }
    $num =  number_format_i18n( $count );
    // Acest bloc va adăuga numărătoarea de cuvinte în secțiunea de statistici din caseta Right Now
    $text = _n( 'Cuvânt', 'Cuvinte', $num );
    echo "<tr><td class='first b'>{$num}</td><td class='t'>{$text}</td></tr>";
    // Această linie va adăuga numărătoarea de cuvinte în partea de jos a casetei Right Now.
    echo '<p>Acest blog conține un total de <strong>' . $num . '</strong> cuvinte publicate!</p>';
}

// adaugă în tabelul Statistici Conținut
add_action( 'right_now_content_table_end', 'post_word_count');
// adaugă în partea de jos a casetei Activitate
add_action('activity_box_end', 'post_word_count');

Mulțumiri speciale lui Rarst pentru optimizarea codului fără interogări!

Încărcarea condiționată a scripturilor

Iată o metodă de a încărca scripturi doar dacă un anumit shortcode sau widget este prezent. sursă: Încărcarea scripturilor doar dacă un anumit shortcode sau widget este prezent

function has_my_shortcode($posts) {
    if ( empty($posts) )
        return $posts;
    $found = false;
    foreach ($posts as $post) {
        if ( stripos($post->post_content, '[my_shortcode') )
            $found = true;
            break;
        }
    if ($found){
        $urljs = get_bloginfo( 'template_directory' ).IMP_JS;
    wp_register_script('my_script', $urljs.'myscript.js' );
    wp_print_scripts('my_script');
}
    return $posts;
}
add_action('the_posts', 'has_my_shortcode');

Și iată cum să încărcați scripturi doar dacă un anumit widget este prezent

Pentru a încărca scriptul doar în pagina unde widget-ul este încărcat, va trebui să adăugați codul is_active_widget() în clasa widget-ului. De exemplu, vedeți widget-ul implicit pentru comentarii recente (wp-includes/default-widgets.php, linia 602):

class WP_Widget_Recent_Comments extends WP_Widget {
    function WP_Widget_Recent_Comments() {
        $widget_ops = array('classname' => 'widget_recent_comments', 'description' => __( 'Cele mai recente comentarii' ) );
        $this->WP_Widget('recent-comments', __('Comentarii Recente'), $widget_ops);
        $this->alt_option_name = 'widget_recent_comments';
        if ( is_active_widget(false, false, $this->id_base) )
        add_action( 'wp_head', array(&$this, 'recent_comments_style') );
        add_action( 'comment_post', array(&$this, 'flush_widget_cache') );
        add_action( 'transition_comment_status', array(&$this, 'flush_widget_cache') );
    }

CSS Personalizat pentru Panoul de Control

/* Modifică CSS-ul panoului de control WordPress */
function custom_admin_styles() {
    echo '<style type="text/css">#wphead{background:#069}</style>';
}
add_action('admin_head', 'custom_admin_styles');

Puteți adăuga orice modificări CSS între tag-urile <style>.

Elimină Prefixele Private și Protejate

Această funcție elimină prefixul "Privat:" din articolele și paginile marcate ca private. Utilă pentru conținut vizibil doar utilizatorilor autentificați sau anumitor grupuri.

function the_title_trim($title) {
$title = attribute_escape($title);
$findthese = array(
    '#Protected:#',
    '#Private:#'
);
$replacewith = array(
    '', // Ce să înlocuiască "Protected:" 
    '' // Ce să înlocuiască "Private:" 
);
$title = preg_replace($findthese, $replacewith, $title);
return $title;
}
add_filter('the_title', 'the_title_trim');

ACTUALIZARE: Am actualizat codul pentru a include și eliminarea prefixului "Protejat:".

Lungime personalizată a rezumatului

function excerpt($num) {
    $limit = $num+1;
    $excerpt = explode(' ', get_the_excerpt(), $limit);
    array_pop($excerpt);
    $excerpt = implode(" ",$excerpt)."... (<a href='" .get_permalink($post->ID) ." '>Citește mai mult</a>)";
    echo $excerpt;
}

Limitează lungimea rezumatului afișat scriind în tema: excerpt('20');

Exemplu: <?php excerpt('22'); ?> Aceasta va limita rezumatul la 22 de caractere.

Rezumatul va fi întrerupt cu ... (Citește mai mult)

Adaugă slug-ul paginii părinte în body_class

/***************************************************************
* Funcția body_class_section
* Adaugă pagina de nivel superior în clasa body pentru secțiuni colorate
***************************************************************/

add_filter('body_class','body_class_section');

function body_class_section($classes) {
    global $wpdb, $post;
    if (is_page()) {
        if ($post->post_parent) {
            $parent  = end(get_post_ancestors($current_page_id));
        } else {
            $parent = $post->ID;
        }
        $post_data = get_post($parent, ARRAY_A);
        $classes[] = 'section-' . $post_data['post_name'];
    }
    return $classes;
}

Acest filtru adaugă o clasă unică body bazată pe cel mai înalt nivel al părintelui paginii curente. Folosesc acest lucru pentru site-uri care au culori sau layout-uri specifice pentru fiecare secțiune a site-ului. Funcționează cel mai bine cu site-uri bazate pe pagini. Exemple CSS:

.section-about { background: red; }
.section-portfolio { background: blue; }

Tema ta trebuie să folosească și funcția body_class.

Remediază obiectele Flash oEmbed

/***************************************************************
* Funcția my_oembed_wmode
* Remediază modul fereastră pentru obiectele Flash oEmbed
***************************************************************/

add_filter('embed_oembed_html', 'my_oembed_wmode', 1);

function my_oembed_wmode( $embed ) {
    if ( strpos( $embed, '<param' ) !== false ) {
        $embed = str_replace( '<embed', '<embed wmode="transparent" ', $embed );
        $embed = preg_replace( '/param>/', 'param><param name="wmode" value="transparent" />', $embed, 1);
    }
    return $embed;
}

Am avut probleme în trecut când obiectele Flash oEmbed intrau în conflict cu meniurile derulante. Acest filtru remediază problema prin adăugarea unui mod transparent al ferestrei la embed-uri.

Elimină coloana "comentarii" din lista paginilor din Admin

/***************************************************************
* Funcția custom_pages_columns
* Elimină "comentarii" din vizualizarea paginilor (rar folosesc comentarii pe pagini)
***************************************************************/

add_filter('manage_pages_columns', 'custom_pages_columns');

function custom_pages_columns($defaults) {
    unset($defaults['comments']);
    return $defaults;
}

Folosesc foarte rar comentariile pe pagini, iar acest lucru ajută la menținerea curățeniei în panoul de control WordPress.

Activează Paginarea Numerică

Testat pe: Wordpress 3.0.1

/* Paginare Numerică ********************************************/

function numeric_pagination ($pageCount = 9, $query = null) {

 if ($query == null) {
  global $wp_query;
  $query = $wp_query;
 }

 if ($query->max_num_pages <= 1) {
  return;
 }

 $pageStart = 1;
 $paged = $query->query_vars['paged'];

 // setează pagina curentă dacă suntem pe prima pagină
 if ($paged == null) {
  $paged = 1;
 }

 // verifică dacă începutul paginilor vizibile este la jumătatea intervalului și ajustează dacă e cazul
 if ($paged > floor($pageCount / 2)) {
  $pageStart = $paged - floor($pageCount / 2);
 }

 if ($pageStart < 1) {
  $pageStart = 1;
 }

 // asigură că începutul paginilor nu depășește numărul total de pagini
 if ($pageStart + $pageCount > $query->max_num_pages) {
  $pageCount = $query->max_num_pages - $pageStart;
 }

?>
 <div id="archive_pagination">
<?php
 if ($paged != 1) {
?>
 <a href="<?php echo get_pagenum_link(1); ?>" class="numbered page-number-first"><span>&lsaquo; <?php _e('<< Prima', 'global'); ?></span></a>
<?php
 }
 // prima pagină nu este vizibilă...
 if ($pageStart > 1) {
  //echo 'previous';
 }
 for ($p = $pageStart; $p <= $pageStart + $pageCount; $p ++) {
  if ($p == $paged) {
?>
  <span class="numbered page-number-<?php echo $p; ?> current-numeric-page"><?php echo $p; ?></span>
<?php } else { ?>
  <a href="<?php echo get_pagenum_link($p); ?>" class="numbered page-number-<?php echo $p; ?>"><span><?php echo $p; ?></span></a>

<?php
  }
 }
 // ultima pagină nu este vizibilă
 if ($pageStart + $pageCount < $query->max_num_pages) {
  //echo "last";
 }
 if ($paged != $query->max_num_pages) {
?>
  <a href="<?php echo get_pagenum_link($query->max_num_pages); ?>" class="numbered page-number-last"><span><?php _e('>> Ultima', 'global'); ?> &rsaquo;</span></a>
<?php } ?>

 </div>

Afisează conținut specific doar pentru utilizatorii autentificați

Testat pe: Wordpress 3.0.1

function content_only4logged_in($content) {

    // TOȚI UTILIZATORII AUTENTIFICAȚI
    if ( is_user_logged_in() &&
            !is_null($content) &&
            !is_feed()
         ) {
        return $content;
    } else {
        $content  = wp_html_excerpt( $content, 80 );
        $content .= ' …';
        $content .= __( 'Ne pare rău, restul acestui conținut este disponibil doar pentru utilizatorii autentificați.', FB_TEXTDOMAIN );
        return $content;
    }
}
add_action( 'the_content', 'content_only4logged_in' );

mai multe posibilități și informații în articolul http://wpengineer.com/2046/control-the-wordpress-content-via-userrights-or-time/

Fă-ți Linkurile Scurte și Mai Scurte prin Eliminarea WWW

Testat pe: Wordpress 3.0.1

Fă-ți linkurile scurte și mai scurte dacă incluzi www. în domeniul tău. Via scratch99.com:

add_filter('get_shortlink','sjc_alter_shortlink');
function sjc_alter_shortlink($shortlink) {
    $shortlink = preg_replace('/^(https?:\/\/)?(www\.)/','$1',$shortlink);
    return $shortlink;
}

Verifică dacă un articol are conținut încorporat

Verifică dacă un articol are conținut încorporat, funcționează în bucla folosind ID-ul articolului curent, sau poate primi un ID pentru a determina articolul care trebuie verificat pentru conținut încorporat.

function has_embed( $post_id = false ) {
    if( !$post_id ) $post_id = get_the_ID();
    else $post_id = absint( $post_id );
    if( !$post_id ) return false;

    $post_meta = get_post_custom_keys( $post_id );
    $post_meta = array_map( 'trim' , $post_meta );

    foreach( $post_meta as $meta ) {
        if( '_oembed' != substr( $meta , 0 , 7 ) )
            continue;
        return true;
    }
    return false;
}

Folosești funcția în același mod în care verifici dacă un articol are o etichetă..

if( has_embed() ) {
   // fă ceva
}

Funcția returnează true dacă găsește un conținut încorporat, false în caz contrar.

Afisarea postărilor din diferite tipuri personalizate de postări pe pagina principală

Prin adăugarea următorului cod la sfârșitul acestui articol în fișierul functions.php, puteți face ca WordPress să afișeze automat postări din diferite tipuri personalizate de postări pe care le-ați creat. În mod implicit, WordPress afișează doar postările care aparțin tipului standard "post".

În exemplul de mai jos, va trebui să modificați secțiunea care conține:

$query->set( 'post_type', array('post', 'page', 'services', 'attachment'));

Cu propriile tipuri personalizate de postări pe care doriți să le includeți în lista de rezultate de pe pagina principală. În acest caz, cerem WordPress să returneze toate postările care aparțin tipurilor standard "post" și "page", apoi să includă și tipul personalizat "services" creat de noi și în final tipul implicit WordPress "attachment", ceea ce înseamnă că orice element adăugat în biblioteca media va fi afișat automat pe pagina principală ca o intrare separată.

// LISTA PERSONALIZATĂ DE POSTĂRI PE PAGINA PRINCIPALĂ, INCLUZÂND DIFERITE POST_TYPE
// asigurați-vă că editați tipurile de postări pe care doriți să le includeți în lista de mai jos
add_filter( 'pre_get_posts', 'my_homepage_post_list' );
function my_homepage_post_list ( $query ) {
    if ( is_home() && false == $query->query_vars['suppress_filters'] )
        $query->set( 'post_type', array('post', 'page', 'services', 'attachment'));
    return $query;
}

De asemenea, puteți utiliza această interogare personalizată în diferite locații, cum ar fi într-un flux personalizat, folosind ceva de genul:

if (( is_home() && false == $query->query_vars['suppress_filters'] ) || is_feed())

Elimină câmpurile implicite de contact din profilul utilizatorului și înlocuiește-le cu ceva mai util

A doua parte a acestei funcții a fost deja menționată mai sus, dar eliminarea câmpurilor implicite - AIM, Yahoo IM și Jabber/Google Talk - nu a fost încă abordată:

function update_contact_methods( $contactmethods ) {

// Elimină câmpurile implicite inutile și nedorite
unset($contactmethods['aim']);  
unset($contactmethods['jabber']);  
unset($contactmethods['yim']);  

// Adaugă câmpuri noi  
$contactmethods['phone'] = 'Telefon';  
$contactmethods['mobile'] = 'Mobil';  
$contactmethods['address'] = 'Adresă';  

return $contactmethods;
}
add_filter('user_contactmethods', 'update_contact_methods');

Desigur, poți adăuga oricâte câmpuri dorești (vezi exemplele anterioare din acest fir) sub secțiunea "Adaugă câmpuri noi"