it-swarm.com.de

Wie füge ich "Diesen Beitrag auf die Titelseite kleben" zum Frontend hinzu?

Ich habe eine Baseball-Website mit mehreren Autoren. Ich benutze "Diesen Beitrag auf die Titelseite kleben", um einen "Editor's Pick" für einen Artikel zu kennzeichnen. Ich möchte einen Link/Button hinzufügen, damit der Editor dies vom Frontend aus tun kann. Die Methode kann sich entweder im Artikel selbst oder in der Admin-Leiste befinden. Ich habe nicht wirklich eine Präferenz.

Ich habe viele, viele verschiedene "Admin Bar" -Plugins durchgesehen, aber noch nichts zum Thema "Diesen Beitrag auf die Startseite kleben" gefunden.

Vielen Dank

6
Travis Pflanz

Ich denke, dieser kleine Quellcode ist Ihre Lösung. Momentan gibt es kein Frontend-Feedback für die Änderung von Sticky Post, aber Sie können diesen String, diese Klasse oder was auch immer in der Funktion fb_stick_post erweitern.

Die erste Funktion fügt das Element in die Admin-Leiste ein und erstellt eine neue URL mit einem Parameterwert. Außerdem ruft on click eine Funktion auf, um den URL-Parameter zu lesen und, falls dies zutrifft, den Status dieser Beitrags-ID zu ändern.

add_action( 'admin_bar_menu', 'fb_add_admin_bar_sticky', 35 );
function fb_add_admin_bar_sticky() {
    global $wp_admin_bar;

    if ( ! is_super_admin() || ! is_admin_bar_showing() )
        return;

    $current_object = get_queried_object();
    if ( empty($current_object) )
        return;

    if ( ! empty( $current_object->post_type ) && 
        ( $post_type_object = get_post_type_object( $current_object->post_type ) ) && 
        current_user_can( $post_type_object->cap->edit_post, $current_object->ID ) 
    ) {
        $wp_admin_bar->add_menu( 
            array(
                'id' => 'sticky_post', 
                'title' => __('Sticky'), 
                'href' => get_permalink() . '?stick_post=true', 
                'meta' => array(
                    'title' => __( 'Click me' ),
                    'onclick' => fb_stick_post( get_the_ID() )
                )
            )
        );
    }
}

function fb_stick_post( $post_id ) {

    if ( isset($_GET['stick_post']) && 'true' == htmlspecialchars( $_GET['stick_post'] ) )
        stick_post( $post_id );
}

Update 30.07.2012

Jetzt ein kleines Plugin mit einfacher Lösung. Das Plugin fügt ein Element in die Admin-Leiste ein. Die Zeichenfolge der Schaltfläche zum Prüfen auf ist klebrig und gibt die Möglichkeit, den aktuellen Beitrag zu kleben oder zu lösen.

Example in Twenty Eleven Theme for an post, there was with an sticky flag

Ich ändere den Haken für das Hinzufügen des Admin-Leisten-Elements zu "template_redirect", um eine Weiterleitung nach dem Aktualisieren des Stick-Flags auf dem Post zu verwenden.

<?php
/**
 * Plugin Name: Stick/Unstick post via Admin bar
 * 
 */

if ( ! function_exists( 'fb_add_admin_bar_sticky' ) ) {

    add_action( 'template_redirect', 'fb_add_admin_bar_sticky' );
    function fb_add_admin_bar_sticky() {
        global $wp_admin_bar;

        if ( ! is_super_admin() || ! is_admin_bar_showing() )
            return;

        $current_object = get_queried_object();
        if ( empty($current_object) )
            return;

        if ( ! empty( $current_object->post_type ) && 
            ( $post_type_object = get_post_type_object( $current_object->post_type ) ) && 
            current_user_can( $post_type_object->cap->edit_post, $current_object->ID ) 
        ) {

            // check, if an sticky post
            if ( is_sticky( get_the_ID() ) ) {
                $title = __('Unsticky');
                $link = '?unstick_post=true';
                $attr_title = __( 'Make this post unsticky' );
            } else {
                $title = __('Sticky');
                $link = '?stick_post=true';
                $attr_title = __( 'Make this post sticky' );
            }

            $wp_admin_bar->add_menu(
                array(
                    'id' => 'sticky_post', 
                    'title' => $title, 
                    'href' => get_permalink() . $link, 
                    'meta' => array(
                        'title' => $attr_title,
                        'onclick' => fb_stick_post( get_the_ID() )
                    )
                )
            );
        }
    }

    function fb_stick_post( $post_id ) {

        if ( isset($_GET['stick_post']) && 'true' == htmlspecialchars( $_GET['stick_post'] ) ) {
            stick_post( $post_id );
            wp_redirect( get_permalink( $post_id ) );
            exit();
        }

        if ( isset($_GET['unstick_post']) && 'true' == htmlspecialchars( $_GET['unstick_post'] ) ) {
            unstick_post( $post_id );
            wp_redirect( get_permalink( $post_id ) );
            exit();
        }
    }

}

oder lade dieses Plugin herunter Gist 3214922

4
bueltge

Es gibt einige nützliche Funktionen:

Unter Berücksichtigung dieser drei Punkte müssen wir sie nur mit etwas Klebstoff für die Admin-Menüleiste zusammenkleben.

Lassen Sie uns zuallererst alles in eine Klasse packen, um Spaß zu haben und Gewinn zu machen. Diese Klasse wird einige Konstanten haben, die wir später verwenden werden: eine Nonce, eine Aktion zum Entfernen des Pfostens und eine Aktion zum Entfernen des Pfostens.

class WPSE_58818_Stick_Post
{
    /**
     * Ajax nonce.
     *
     * @since   1.0
     */
    const NONCE = 'wpse58818_nonce_';

    /**
     * Unstick ajax action
     *
     * @since   1.0
     */
    const UNSTICK = 'wpse58818_unstick';

    /**
     * Stick Ajax action
     *
     * @since   1.0
     */
    const STICK = 'wpse58818_stick';
} // end class

Dann fügen wir eine Init-Funktion hinzu, um unsere Aktionen hinzuzufügen. Die erste Aktion ist, dass wir template_redirect einbinden.

<?php
class WPSE_58818_Stick_Post
{
    // snip snip

    /**
     * Adds actions and such.
     *
     * @since   1.0
     * @access  public
     * @uses    add_action
     */
    public static function init()
    {
        add_action(
            'template_redirect',
            array(__CLASS__, 'template_r')
        );
    }
}

HINWEIS: Von hier an werde ich das class-Bit weglassen. Sie können die ganze Sache sehen hier .

In der Funktion, die in template_redirect eingebunden ist, wird geprüft, ob wir uns auf einer einzelnen Beitragsseite befinden und ob der Benutzer sie bearbeiten kann. Wenn sie können, werden wir uns in admin_bar_menu und wp_footer einklinken.

/**
 * Hooked into `template_redirect`.  Adds the admin bar stick/unstick
 * button if we're on a single post page and the current user can edit
 * the post
 * 
 * @since   1.0
 * @access  public
 * @uses    add_action
 */
public static function template_r()
{
    if(
        !is_single() ||
        !current_user_can('edit_post', get_queried_object_id())
    ) return; // not a single post or the user can't edit it

    // Hook into admin_bar_menu to add stuff
    add_action(
        'admin_bar_menu',
        array(__CLASS__, 'menu'),
        100
    );

    // Hook into the footer and spit out some JavaScript
    add_action(
        'wp_footer',
        array(__CLASS__, 'footer')
    );
}

In der Funktion menu, die in admin_bar_menu eingebunden ist, können wir unseren neuen Artikel hinzufügen:

/**
 * Hooked into `admin_bar_menu`.  Adds our stick/unstick node.
 *
 * @since   1.0
 * @access  public
 */
public static function menu($mb)
{
    // get the current post ID
    $post_id = get_queried_object_id();

    $mb->add_node(array(
        'id'    => 'wpse58818-sticker',
        'meta'  => array(
            'class' => 'wpse58818-sticker',
            'title' => is_sticky($post_id) ? 'unstick' : 'stick'
        ),
        'title' => is_sticky($post_id) ? __('Unstick') : __('Stick'),
        'href'  => self::get_url($post_id)
    ));
}

Hier erhalten wir unsere erste "Utility-Funktion", die eine URL für den Knoten der Admin-Menüleiste erstellt. Es ist nur ein Wrapper um add_query_arg und eine URL, die wir später mit AJAX verwenden werden:

/**
 * Get an Ajax URL to use for a given post
 *
 * @since   1.0
 * @access  protected
 */
protected static function get_url($post_id)
{
    return add_query_arg(array(
        'post_id' => absint($post_id),
        'action'  => is_sticky($post_id) ? self::UNSTICK : self::STICK,
        'nonce'   => wp_create_nonce(self::NONCE . $post_id)
    ), admin_url('admin-ajax.php'));
}

Die Funktion footer spuckt nur etwas JavaScript aus, um die AJAX -Aufrufe auszuführen. Grundlegender Überblick: Wenn jemand auf unseren neuen Link klickt, senden Sie eine GET-Anfrage an die angegebene URL. Wenn es erfolgreich ist, ändern Sie die Href, den Text und den Titel des (Un-) Stick-Links.

/**
 * Hooked into `wp_footer`.  Spits out a bit of JS to stick/unstick a post
 *
 * @since   1.0
 * @access  public
 */
public static function footer()
{
    ?>
    <script type="text/javascript">
    jQuery(document).ready(function($) {
        $('.wpse58818-sticker a').on('click', function(e) {
            e.preventDefault();
            var action = $(this).attr('title');
            var that = this;
            $.get(
                $(this).attr('href'),
                {},
                function(data) {
                    if('0' == data)
                    {
                        console.log(data);
                        alert('<?php echo esc_js(__('An error occurred')); ?>');
                        return;
                    }

                    $(that).attr('href', data);
                    if('stick' == action) {
                        $(that).html('<?php echo esc_js(__('Unstick')); ?>');
                        $(that).attr('title', 'unstick');
                    } else {
                        $(that).html('<?php echo esc_js(__('Stick')); ?>');
                        $(that).attr('title', 'stick');
                    }
                }
            );
        });
    });
    </script>
    <?php
}

Und jetzt kommen wir zu den AJAX Rückrufen. Ajax in Plugins/Themes ist es wert, darüber nachzulesen.

Wir werden unsere Funktion init etwas modifizieren, um zwei weitere Aktionen hinzuzufügen:

/**
 * Adds actions and such.
 *
 * @since   1.0
 * @access  public
 * @uses    add_action
 */
public static function init()
{
    add_action(
        'template_redirect',
        array(__CLASS__, 'template_r')
    );

    // Ajax actions
    add_action(
        'wp_ajax_' . self::STICK,
        array(__CLASS__, 'stick')
    );

    add_action(
        'wp_ajax_' . self::UNSTICK,
        array(__CLASS__, 'unstick')
    );
}

Und unsere AJAX Rückrufe. Dies könnte sehr leicht die gleiche Funktion sein. Ich habe sie hier aufgeteilt, weil es in Zukunft einfacher schien, sie zu erweitern/zu ändern. In beiden Fällen wird geprüft, ob die Anforderung AJAX gültig ist. Anschließend wird der Beitrag entsprechend gelöscht und die neue URL für das zukünftige Löschen ausgegeben.

/**
 * Ajax callback for the stick function
 *
 * @since   1.0
 * @access  public
 */
public static function stick()
{
    $post_id = self::can_ajax();

    stick_post($post_id);

    echo self::get_url($post_id);
    die();
}

/**
 * Ajax callback for the unstick function
 *
 * @since   1.0
 * @access  public
 * @uses    unstick_post
 */
public static function unstick()
{
    $post_id = self::can_ajax();

    // nonces checked, everything is good to go. Unstick!
    unstick_post($post_id);

    echo self::get_url($post_id);
    die();
}

Unsere zweite "Utility-Funktion" taucht hier auf. can_ajax überprüft unsere Nonces und Benutzerberechtigungen und gibt die Post-ID an (un) stick zurück. Wenn eine Überprüfung fehlschlägt, wird sie beendet (über die('1')).

/**
 * Check to see if the current user can ajax.  Returns the post ID to 
 * stick/unstick if successful. Kills the program otherwise
 *
 * @since   1.0
 * @access  protected
 */
protected static function can_ajax()
{
    $post_id = isset($_REQUEST['post_id']) ? $_REQUEST['post_id'] : '';

    if(
        !$post_id ||
        !check_ajax_referer(self::NONCE . $post_id, 'nonce', false)
    ) die('0');

    if(!current_user_can('edit_post', $post_id))
        die('0');

    return $post_id;
}

Hier ist das ganze Chaos als Plugin .

7
chrisguitarguy

Hier ist eine viel einfachere Lösung, die die Arbeit mit the_content filter hook erledigt

add_filter('the_content','simplest_sticky_solution');
function simplest_sticky_solution($content){
    global $post;
    //early exit if not needed
    if (!is_single() || !current_user_can('edit_post',$post->ID)) 
        return $content;

    //check if form is submitted and act as needed
    if (isset($_POST['sticky_action']) && isset($_POST['sticky_id']) && isset($_POST['sticky_nonce']) && wp_verify_nonce($_POST['sticky_nonce'], 'StickIt')){
        if (is_sticky($post->ID)){
            stick_post($post->ID);
        }else{
            unstick_post($post->ID);
        }
    }

    //create the form
    $label = (is_sticky())? "Unstick": "Stick";
    $form = '
    <form action="" method="POST">
        <input type="hidden" name="sticky_id" value="'.$post->id.'">
        <input type="hidden" name="sticky_action" value="stickit">
        <input type="hidden" name="sticky_nonce" value="'.wp_create_nonce('StickIt').'">
        <input type="button" name="submit" value="'.$label.'">
    </form>';
    return $form.'<br/>'.$content;
}
3
Bainternet