Alle diese Lösungen haben ihre Grenzen, sind unflexibel und man begibt sich in eine Abhängigkeit, die man nur schwer wieder los wird und mit jedem Update von WordPress bekommt man es mit der Angst oder Minimum einem recht großen Aufwand im Testen zu tun. Darum möchte ich eine Lösung vorstellen, die wir im Team Inpsyde vielfach bei Kunden einsetzen und die ihre Stärke in der Flexibilität hat, in der Erweiterbarkeit und in der Eigenschaft, den WordPress Standard zu nutzen und nicht zu verbiegen. Ein Abschalten ist jederzeit möglich; das System bleibt in seinem Zustand.

Warum mehrsprachig?

• 2/3 der Weltbevölkerung sprechen mehr als eine Sprache
• Globale Aufstellung von Unternehmen
• Streuung von Inhalten
• Service am Kunden
• Suchmaschinenoptimierung

Die Lösung

WordPress Multisite liefert die Lösung am Standard.
Damit wird die Verwaltung verschiedener Instanzen, mit Gemeinsamkeiten und Unterschieden, mit Hilfe einer Installation möglich. Der Austausch von Daten ist via Core-Funktionen möglich, welche mittels Plugins gebündelt und vereinfacht werden.

Vorteile

• WordPress Core Funktionen
• Keine Abhängigkeiten von Plugins – überlebensfähig
• Unabhängig von WordPress Entwicklung*
• Themes, Plugins zentral steuern, dezentral nutzen
• Geringer Wartungsaufwand
• Trennung Sprachen in Backend/Frontend (Userabhänig)
• Komplett gespiegelt oder in jeder Inhaltsform getrennt
• Kulturelle Hintergründe getrennt umsetzbar
• Subdomains oder Subdirectories
• de.example.com, example.com/de
• Getrennte Domains via Domainmapping
• example.de, example.com
• Freiheit der Entwicklung in Design und Nutzeranforderung
• Optimierung nicht nur im sichtbaren Bereich, lang-Attribute, SEO

Weitere Ausführungen zu Frage, Ansatz und Lösung findet ihr den Slides zum WordCamp 2011.

Unterstützung via Plugin

Mit all diesen Anforderungen und Vorteilen nutzen wir eine Basis, die als Plugin im offiziellen Repository von WordPress zur Verfügung steht Multilingual Press. Das Plugin liefert einige Werkzeuge um Multisite komfortabel für den Einsatz in der Mehrsprachigkeit umzusetzen.

Dieses Plugin erleichtert die Zuordnung der unterschiedlichen Blogs im Netzwerk zu einer Sprache und der Verknüpfung zu anderen Blogs, so dass beim Publizieren in Blog A der Inhalt in anderen Blogs als Draft abgelegt wird. So stehen die Artikel in Relation, das System kennt ihre Zugehörigkeit und mit Hilfe einiger Funktionen kann dies im Frontend und Backend genutzt werden.
Das Plugin liefert die Möglichkeit, dass am Artikel und Seite eine Meta Box mit dem Inhalt der verlinkten Daten zu sehen ist; im einfachsten Fall als Übersetzungshilfe. Ebenso gibt es ein Widget, welches im Frontend die Umschaltung erleichtert. Je Blog können einige Einstellungen vorgenommen werden, so dass eine Sprache, Flagge zugeordnet ist.

Ausblick

Wir haben eine weitere Version in Arbeit, die zusätzliche Hilfe mitbringt; z.B. ein Dashboardwidget mit der Übersicht alles Artikel und Verknüpfungen, einer Erweiterungen der Mediathek um globale Inhalte über alle Blogs und eigenständige Inhalte pro Blog zu trennen, in den Rechten und der Bedienung. Ebenso gibt es Helfer für das Updaten von bestehenden Installationen. Im weiteren besteht die Möglichkeit die Sprachpakete direkt im Backend zu laden, ohne via FTP/SSH auf den Server zu greifen und die Sprachen zuzuordnen. Unterstützen können wir auch, wenn ein Blog neu im Netzwerk angelegt wird, in dem bestehende Blogs als Vorlage dienen und Optionen u.a. kopiert werden. Dies aber nur ein kleiner Ausblick.

Fazit

WordPress Multisite liefert die Basis und mit einigen Anpassungen ensteht eine saubere, kontrollierte Lösung für die Nutzung von WordPress im mehrsprachigen Umfeld. Nun liegt es an euch - Multisite nutzen, Plugin testen und Rückmeldungen sehen wir gern am Repo auf Github.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Warum WordPress kein MVC-Pattern konsequent verfolgt?

Betrachteten wir WordPress auf eine beschränkte Sichtweise, kann man ein MVC-Pattern erkennen. Durch die Trennung der Themes (view) vom Core (Model) wird der Eindruck erweckt WordPress verfolgt ein MVC-Pattern. Aber dieses Muster ist nur im Fontend zu finden. Schauen wir allerdings etwas genauer hin sehen wir das es keine solche Logik für den Adminbereich gibt. Also muss die View für den Adminbereich irgendwo im Core verankert sein. Wir können auch feststellen das im Core selbst lose SQL-Query innerhalb von PHP zu finden ist. Gut, eine allgemeine Trennung von Ansicht und Logik ist nicht gleich MVC. Ein MVC-Pattern geht prinzipiell von einer Art objektorientierten Programmier-Paradigma aus, in WordPress sind diese auch vereinzelt zu finden, aber wir finden viel mehr prozedurale Programmier-Paradigmen als objektorientierte. Fazit WordPress selbst verfolgt kein MVC-Pattern, aber es ist durchaus möglich MVC-Prinziepien, wie im folgernden an zuwenden.

function get_some_foo() {
	$my_foo = 'This is Foo!';
	return $my_foo;
}

function some_foo() {
	$foo = get_some_foo();
	echo $foo;
}

Warum ist das Sinnvoll? Wir wollen das die Funktion some_foo() eine vordefinierte Ausgaben zurückliefert. In einem anderen Template wollen wir aber das vordefinierte Verhalten der Funktion some_foo() verändern. Um nun beiden Anforderungen effektiv abzubilden, werden zwei Funktionen definiert. Die erste Funktion besteht einzig aus der elementaren Logik und gibt nur Werte als return zurück, ihr wird immer ein get_… vorangestellt. Die zweite Funktion enthält vordefinierte Darstellungsinformationen, das wiederum können HTML, Prüflogik, Schleifen oder ein Hook sein.

function get_some_foo() {
	$foo_bar_array = array( 'Foo', 'Bar', 'FooBar', 'BarFoo' );
	$foo_bar_array = apply_filters( 'some_foo_array', $foo_bar_array );

	return $foo_bar_array ;
}

function some_foo() {
    $foo_list = '<ul>'; 

    foreach( get_some_foo() as $foo_key => $foo_value ){
		$foo_list .= '<li>' . $foo_value . '</li>';
    }

    $foo_list .= '</ul>';

    echo apply_filters( 'some_foo', $foo_list );
}

Im vorherigen Beispiel wird in jeder der beiden Funktionen mit der Funktion apply_filters() die möglichkeiten geschaffen, zurückgeliferte Werte später beliebig zu verändern. Eine Manipulation kann dann über die so definierten Hooks some_foo_arra oder some_foo erfolgen. Hier noch ein Beispiel, wie eine möglich Manipulation mit den beiden defineirten Hooks aussehen kann.

Im nächsten Code-Beispiel werden wir ein Array $foo_bar_array und das HTML von der Ausgbe Verändern. Dazu werden die beiden Hooks some_foo_array und some_foo, die mit apply_filters( 'some_foo' ... festgelegt wurden genutzt. Mit der Funktion add_filter() werden Filterfunktionen zur Weiterverarbeitung in der globalen Variable $wp_filter registriert.

function get_my_some_foo( $foo_bar_array ) {
	$foo_bar_array[ count( $foo_bar_array ) + 1 ] = 'FuuBoo';

	return $foo_bar_array ;
}

function my_some_foo( $foo_list ) {
    $foo_list = str_replace( 'ul', 'ol', $foo_list ); 

    return $foo_list;
}

add_filter( 'some_foo_array', 'get_my_some_foo');
add_filter( 'some_foo', 'my_some_foo');

// do not forget, call some_foo()
some_foo();

Schauen wir uns noch kurz an was das ganze nun bewirkt. Was some_foo() ohne Manipulieren ausgibt sehen wir im folgenden Beispiel.

function get_some_foo() {
	$foo_bar_array = array( 'Foo', 'Bar', 'FooBar', 'BarFoo' );
	$foo_bar_array = apply_filters( 'some_foo_array', $foo_bar_array );

	return $foo_bar_array ;
}

function some_foo() {
    $foo_list = '<ul>'; 

    foreach(get_some_foo() as $foo_key => $foo_value){
		$foo_list .= '<li>' . $foo_value . '</li>';
    }

    $foo_list .= '</ul>';

    echo apply_filters( 'some_foo', $foo_list );
}
?> 

//Ausgabe
<ul>
	<li>Foo</li>
	<li>Bar</li>
	<li>FooBar</li>
	<li>BarFoo</li>
</ul>

Im nächsten Beispiel nutzen wir die in den Funktionen definierten Hooks some_foo_array und some_foo um dem Array ein weiteres Element hinzuzufügen und aus der ungeordneten Liste eine geordnete Liste zu machen.

function get_my_some_foo( $foo_bar_array ) {
	$foo_bar_array[ count( $foo_bar_array ) + 1 ] = 'FuuBoo';

	return $foo_bar_array ;
}

function my_some_foo( $foo_list ) {
    $foo_list = str_replace( 'ul', 'ol', $foo_list ); 

    return $foo_list;
}

// register Hooks in the stack ($wp_filter)
add_filter( 'some_foo_array', 'get_my_some_foo');
add_filter( 'some_foo', 'my_some_foo');
?>

//output
<ol>
	<li>Foo</li>
	<li>Bar</li>
	<li>FooBar</li>
	<li>BarFoo</li>
	<li>FuuBoo</li>
</ol>

Wie Läuft das jetzt mit dem add_filter und apply_filters im Programmfluss ab?
Jeder Hook der ausgeführt werden soll wird mit add_filter oder add_action in der globalen Variable $wp_filter registriert. Wird nun im Programmablauf die Funktion apply_filters() aufgerufen wird anhand der übergeben Parameter die passende Filter-Funktion in der $wp_filter gesucht, wenn dieser mit add_filter dort registiert ist, wird die passende Funktion ausgeführt. Jetzt werden Werte Manipuliert und dann zurück an apply_filters übergeben.

Nehmen wir unser Beispiel von oben, dann sieht das wie folgt aus.

<?php
// the default function
function get_some_foo() {
	$foo_bar_array = array( 'Foo', 'Bar', 'FooBar', 'BarFoo' );
	$foo_bar_array = apply_filters( 'some_foo_array', $foo_bar_array );

	return $foo_bar_array ;
}

// the filter function
function get_my_some_foo( $foo_bar_array ) {
	$foo_bar_array[ count( $foo_bar_array ) + 1 ] = 'FuuBoo';

	return $foo_bar_array ;
}

// register function in $wp_filter
add_filter( 'some_foo_array', 'get_my_some_foo' );
?>

Ohne Hook-Funktionalität würde das Ganze wie folgt aussehen. Wir haben hier zwar wesentlich weniger Code aber dieser ist dafür nicht flexibel oder wiederverwendbar.

<?php
//Das ist unsere default Funktion
function get_some_foo() {
	$foo_bar_array = array( 'Foo', 'Bar', 'FooBar', 'BarFoo' );
	$foo_bar_array[ count( $foo_bar_array ) + 1 ] = 'FuuBoo';

	return $foo_bar_array ;
}
?>

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Eine ähnliche Problematik stellt sich, wenn man den Source der Scripte nicht einfach in den Footer-Bereich von WordPress schreibt, sondern sauber in eine Datei auslagert und via wp_enqueue_script() inkludiert. Nur so kann WordPress diese Scripte mit verwalten, packen und optimiert ausliefern. Daher möchte ich in zwie Beispielen aufzeigen, wie man Daten von PHP an JS übergibt.

Die ersten Schnipsel nutzen die Übergabe von Werten via JSON; wobei ich die Werte aus der Datenbank mit den gängigen Mitteln in PHP hole und das Script direkt im head der Seite die Werte als Objekt ablegt.

add_action( 'admin_enqueue_scripts', 'fb_print_scripts' );

function fb_print_scripts() {
	global $current_screen;

	if ( isset( $current_screen -> id ) && ! in_array( $current_screen -> id, array( 'post', 'page' ) ) )
		return;

	if ( is_plugin_active_for_network( plugin_basename( __FILE__ ) ) )
		$options = get_site_option( 'my_options_id' );
	else
		$options = get_option( 'my_options_id' );

	if ( ! $options )
		return;
	?>
	<script type="text/javascript">
		var my_json_object = <?php echo htmlspecialchars( json_encode( $options ) ); ?>;
	</script>
	<?php
}

Die obige Funktion gibt nun die Werte aus der Datenbank als JSON-Objekt in den head im Backend, da im ersten Schritt der Funktion die Seite abgefragt wird. Mittes $current_screen wird geprüft, so dass nur ausgeliefert wird, wenn man auf der definierten Seiten (post, page) ist.

Der folgende Schritt ist üblich und best practice in WordPress um Scripte einzubringen. Dabei inkludiere ich das JS-File, welches dann auf das JSON-Objekt zugreift.

add_action( 'admin_enqueue_scripts', 'fb_admin_enqueue_scripts' );

function fb_admin_enqueue_scripts( $where ) {

	if ( ! in_array( $where, array( 'post.php', 'post-new.php', ) )
		return;

	$suffix = defined('SCRIPT_DEBUG') && SCRIPT_DEBUG ? '.dev' : '';

	wp_enqueue_script(
		self :: get_textdomain() . '_script',
		plugins_url( '/js/my_script' . $suffix. '.js', __FILE__ ),
		array( 'jquery', 'my_other_script' ),
		'',
		TRUE
	);

}

Im Script wird dann direkt auf das Objekt zugegriffen, welches verarbeitet wird.

jQuery( document ).ready( function( $ ) {

	if ( typeof my_json_object == 'undefined' )
		return;

// debug in console of Browser
console.dir( my_json_object ); 

});

Eine weitere Lösung soll im Folgebeitrag der diesjährigen Serie vorgestellt werden; der Link folgt.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Das heisst also folgendes: Sind wir in der Zeitzone Berlin ist die lokale Zeit UTC+1. Tragen wir ein Scheduled Event ein, hängt er immer eine Stunde nach. Um das zu ändern hilft folgende Funktion:

function get_offset_to_gmt_in_seconds() {

	$current_timezone_offset = get_option( 'gmt_offset' );
	$offset = $current_timezone_offset * 3600;

	return $offset;
}

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

// only for errors an parse
$filename = preg_replace(
    "/\<\!\[CDATA\[(.*?)\]\]\>/ies",
    "'[CDATA]' . base64_encode('$1') . '[/CDATA]'",
    $filename
);
// load cml file
$xml      = simplexml_load_string( $filename );
$json     = json_encode( $xml );
$options  = json_decode( $json,TRUE );
// see result
var_dump( $options );

// update in WordPress
update_option( 'my_settings_id', $options );

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Vielen ist gleich, aber nicht alles und in diesem kleinen Beitrag möchte ich kurz darstellen, wie man beim Aktivieren eines Plugins gesetzte Einstellungen in der Datenbank absetzt. Der optimale Fall dafür ist eine Funktion von WordPress, die beim Aktivieren eines Plugins getriggert wird register_activation_hook(). Diese Funktion wird üblicher weise beim init oder im Construktor des Plugins aufgerufen. In der damit aufgerufenen Funktion stecken die Funktionen um die Voreinstellungen in WordPress in der Tabelle options abzulegen - add_option(). In Multisite gibt es auch dafür eine Funktion - add_site_option().

Nun gilt es nur noch zu trennen, ob das Plugin innerhalb des Network, in der Verwaltung der Multisite-Installation aktiviert wird, oder ob es lediglich in einer der Blogs des Netzwerkes oder einer Single-installation genutzt wird. Dafür gibt es aktuell keine Funktion, aber einen Wert, der übergeben wird. Das nachfolgenden Beispiel verdeutlicht es sicher.

register_activation_hook( __FILE__, 'fb_add_config' );
function fb_add_config() {

	$data = array(
		'active' => 0,
		'radio'  => 0,
		'link'   => 1,
		'theme'  => 1,
		'role'   => 'administrator',
		'unit'   => 1,
	);
	// if is active in network of multisite
	if ( is_multisite() && isset($_GET['networkwide']) && 1 == $_GET['networkwide'] ) {
		add_site_option( 'my_settings_id', $data );
	} else {
		add_option( 'my_settings_id', $data );
	}
}

Die Abfrage des Wertes in der globalen GET ist sicher schlüssig und die Abbildung dieser Abfrage kann sauber in die bereits vor geraumer Zeit angesprochene Lösung für Multisite und Settings von Thomas integriert werden.
Um weitere Abfragen im Umfeld Multisite zu lösen und die Einstellungen wieder zu entfernen, oder Menus im Network-Admin-Bereuch zu integrieren, ist die Funktion is_plugin_active_for_network() nützlich.

So lassen sich beispielsweise die Optionen wieder kontrolliert in Abhängigkeit der Installationsform von WordPress holen.

if ( is_multisite() && is_plugin_active_for_network( plugin_basename( __FILE__ ) ) )
	$values = get_site_option( 'my_settings_id' );
else
	$values = get_option( 'my_settings_id' );

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Einige Hintergründe

Scripte und Stylesheets kann man in WordPress auf verschieden Art in die Ausgabe einbringen, das gilt für Backend und Frontend. Dabei ist das klassiche Verfahren eines meta-Elementes im head oder footer-Bereich nicht zu empfehlen, denn WordPress kann seit Version 2.1 die Verwaltung der Scripte und Stylesheets übernehmen - Vorraussetzung ist die Nutzung der Möglichkeiten rund um wp_enqueue_script() und wp_enqueue_style(). Damit werden diverse Vorteile direkt duch den WordPress-Kern übernommen; komprimieren und gemeinsames Ausliefern in jeweils einer Datei alle Scripte und Stylesheets. Ebenso kümmert sich WordPress darum, dass jedes Script nur einmal in der Auslieferung vorhanden ist; also nicht ein bekanntes Problem wie die mehrfache Verwendung von jQuery zulassen.
Aktuell gibt es dazu immer wieder ähnliche Ansätze mit diversen JS-Lösungen. WordPress kann sich darum kümmern und optimiert ausliefern, jedes Script nur einmal und einfach via ID auf die Scripte zugreifen.

Um nun aber die includierten Scripte und Stylesheets sauber auszuwerten, bedarf es einiger Zugriffe oder die kleine folgende Lösung und schon sind alle eingebundenen Dateien in einer Liste. Die folgenden Funktion kippt die Adressen einfach in den Footer von WordPress, Frontend - wp_footer und Backend - admin_footer, dies kann via Hook natürlich angepasst werden; dies soll nur eine Idee sein und einen Ansatz liefern.
Parallel habe ich es im Plugin Debug Objects integriert und die neue Version sollte in den weihnachtlichen Tagen online gehen.

// view on frontend footer
add_action( 'wp_footer', 'fb_urls_of_enqueued_stuff' );
// view on backend footer
add_action( 'admin_footer', 'fb_urls_of_enqueued_stuff' );
// get engueued scripts and style urls
function fb_urls_of_enqueued_stuff( $handles = array() ) {
	global $wp_scripts, $wp_styles;

	// scripts
	foreach ( $wp_scripts -> registered as $registered )
		$script_urls[ $registered -> handle ] = $registered -> src;
	// styles
	foreach ( $wp_styles -> registered as $registered )
		$style_urls[ $registered -> handle ] = $registered -> src;

	if ( empty( $handles ) ) {
		$handles = array_merge( $wp_scripts -> queue, $wp_styles -> queue );
		array_values( $handles );
	}
	$output = '';
	foreach ( $handles as $handle ) {
		if ( ! empty( $script_urls[ $handle ] ) )
			$output .= $script_urls[ $handle ] . '<br>';
		if ( ! empty( $style_urls[ $handle ] ) )
			$output .= $style_urls[ $handle ] . '<br>';
	}

	echo $output;
}

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Um einigen Hilfesuchenden zu helfen, hier einige Lösungsvorschläge, die man abarbeiten kann. Einige sind nur im Zusammenhang mit WordPress zu nutzen, da die Funktion aus dem Core kommt. Ähnliche Sachen gibt es natürlich auch ohne WP.

Die Erste Lösung ist direkt in den Kommentaren von PHP.net zur Funktion hinterlegt.

$object = preg_replace( '!s:(\d+):"(.*?)";!e', "'s:'.strlen('$2').':\"$2\";'", $object );

Ähnlich geht der folgende Ansatz:

$object = preg_replace( '/;n;/', ';N;', $object );

Alternativ schwören andere auf die Verwendung von trim()

$object = trim( $object );

Aber auch mit diesen Lösungen kommt man nicht immer ans Ziel und die Abfrage, ob es sich um serialisierte Daten handelt muss her. Normalerweise kümmert sich unserialize() darum, aber wie gesagt; nicht immer hilft dies. WordPress stellt eigene Funktionen dafür zur Verfügung.

• is_serialized( $data )
• is_serialized_string( $data )

Mit diesen beiden Funktion kann sauber abgefragt werden.
Aber auch da kann man mit einem einfachen Snippet ran; eventuell nicht der Weisheit letzter Schluss, daher lieber die Funktionen nutzen oder außerhalb von WP eine eigene Funktion, siehe Gist 1415653.

$is_serialized = preg_match( "/^(O:|a:)/", $object );

Vielleicht hilft es dem einen oder anderen, ansonsten nutze ich es als Gedächtnisstütze.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

// only example; control about register_activation_hook()
add_action( 'admin_init', 'fb_activate_plugins' );
function fb_activate_plugins() {

	if ( ! current_user_can('activate_plugins') )
		wp_die(__('You do not have sufficient permissions to activate plugins for this site.'));
	$plugins = FALSE;
	$plugins = get_option('active_plugins'); // get active plugins

	if ( $plugins ) {
		// plugins to active
		$pugins_to_active = array(
			'hello.php', // Hello Dolly
			'adminimize/adminimize.php', // Adminimize
			'akismet/akismet.php' // Akismet
		);

		foreach ( $pugins_to_active as $plugin ) {
			if ( ! in_array( $plugin, $plugins ) ) {
				array_push( $plugins, $plugin );
				update_option( 'active_plugins', $plugins );
			}
		}

	} // end if $plugins

}

Die nachstehende Funktion und dessen Hook sorgen für eine direkte Ausgabe auf der Plugin-Seite im Backend des Strings zur Plugin-Datei, also bitte nur zum schnellen Finden nutzen.

add_filter( 'plugin_row_meta', 'fb_get_plugin_string' , 10, 4 );
function fb_get_plugin_string( $plugin_meta, $plugin_file, $plugin_data, $status ) {
	// echo plugin file string
	echo '<code>' . $plugin_file . '</code><br>';
	return $plugin_meta;
}

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Ebenso werden neue Berechtigungsobjekte angelegt, so dass man die Rechte der Schnipsel auf unterschiedliche Rollen verteilen kann. Über eine eigene Strukturierung mittels Taxonomie können die Schnipsel gefiltert werden.

Das Plugin ist mein erster Versuch im Bereich der Premiumplugins und gibt es schon länger, lediglich die Kurzvorstellung hier im Blog hat immer gefehlt und so hole ich dies mit diesem Artikel nach. Ideen und Hinweise sind sehr willkommen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Dabei werden aber die Inhalt nicht in den Standard-Feed geholt, sondern ein eigenständiger Feed entsteht. Um die Inhalte der CPT in den Haupt-Feed von WordPress zu holen, muss via Hook nur der CPT bekannt gegeben werden; am besten direkt im Plugin, welches sich um die CPT kümmert. Der folgenden kleine Schnipsel erledigt dies beispielsweise.
Dabei werden in den Parametern nur einige Werte übergeben, die dafür sorgen, dass nur Artikel integriert werden, die öffentlich sind und die Recht von post haben; dies Parameter kann man natürlich anpassen; siehe Codex zur Funktion get_post_types().

// add custom post type to wp post-feed
add_action( 'request', 'fb_add_to_feed' );

// add to post-feed
function fb_add_to_feed ( $request ) {

	if ( isset( $request['feed'] ) && ! isset( $request['post_type'] ) ) {
		$request['post_type'] = get_post_types ( $args = array (
			'public'          => TRUE,
			'capability_type' => 'post'
		) );
	}

	return $request;
}

Damit werden dem Standard-Feed zu post die Daten übergeben; der Query dafür wird quasi verändert. Wenn es aber verschiedene CPTs gibt und man diese im Feed definieren will, dann muss der CPT übergeben werden, dazu Beispiel zwei ansehen.
In diesem Schnipsel werden in einem Array die CPT definiert und damit an den Feed übergeben.

// add custom post type to wp post-feed
add_action( 'request', 'fb_add_to_feed' );

// add to feed
function fb_add_to_feed ( $request ) {

	if ( isset( $request['feed'] ) && ! isset( $request['post_type'] ) ) {
		$request['post_type'] = array(
			'post', 'stippet', 'archive', 'movies'
		);
	}

	return $request;
}

Der obige Schnipsel ändert den Query dahingehend, dass die Post Typen definiert werden, die im Feed sein sollen, während im ersten beispiel alles zum Feed addiert wird.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Was mach ich hier eigentlich und warum?

Ich wollte mich mal auf eine von mir, durchaus unübliche Art und Weise bei Frank für seine stets hilfsbereite Art und für die vielen nützlichen Publikationen, in Form eines Gastbeitrages zu unserem Lieblings Thema - WordPress bedanken!.

Zwischen uns mögen Welten liegen, eigentlich sind es ca. 71km aber ich finde es immer wieder faszinierend wie ähnlich manche unserer Gedanken sind. Ok bevor ich abschweife, worum soll es denn jetzt gehen?
Ich stand vor Kurzem vor der Aufgabe ein Plugin zu entwickeln, das mit sehr wenig Optionen daher kommt - eigentlich war es nur eine Option! Aus meiner Sicht war es jetzt nicht wirklich sinnvoll, dafür eine extra Optionsseite anzulegen. Also hab ich mich auf die Suche nach einer Alternative gemacht. Die passende Idee hatte ich schnell. Ich platziere mein einzelnes Eingabefeld dort, wo es am ehesten gefunden wird. Wo das ist? Hm? Natürlich dort wo wir alle Plugins aktivieren, in der Plugin-Tabelle im Backend und zwar direkt unterhalb meines Plugins.

Nun stellt sich bei solchen Ideen folgende Frage:
Gibt es da einen Hook? "Klar mit Sicherheit!"
Wie könnte dieser oder diese Hooks heißen? "Hm keene ahnung!"

Diese beiden Fragen würde ich allerdings gerne mit euch auf dem WordCamp 2011, in der Session "Hook Me" diskutieren. Ich will hier nur das Ergebnis erläutern.

Zu erst werden wir einen weiteren Link zu den Standard Pluginoptionen, Deaktivieren und Bearbeiten hinzufügen.
Hier für wird der Hook plugin_action_links_{$plugin_file} verwendet. Dieser Hook kann 3 Werte an die aufgerufene Funktion übergeben.
Das wären array_filter( $actions ), $plugin_file und $plugin_data. Für unseren Zweck ist der Erste interessant. Mit array_filter( $actions ) erhalten wir die Standard-Optionen in Form eines Arrays, dieses Array müssen wir nun nur noch um die neue Option erweiter.

add_filter( 'plugin_action_links_plugin-options.php, 'po_plugin_action_links', 10, 3 );
function po_plugin_action_links( $array ) {
    $array['opdtions'] = '<a href="#" id="po_options_switch">' . __( 'Einstellungen', 'my_textdomain' ) . '</a>';
    return $array;
}

Jetzt hat unser Plugin eine weitere Option Einstellungen erhalten.
Wo stecken wir denn nun das Eingabefeld hin?

Wenn wir uns die Stelle wo sich der Hook "plugin_action_links_{$plugin_file}" befindet näher anschauen, finden wir wenige Zeilen weiter unten folgenden Hook "after_plugin_row_{$plugin_file}". Mit diesem Hook können wir uns eine eigene Zeile in der Tabelle unterhalb unseres Plugins erzeugen. Auch diesem Hook werden wieder verschiedene Werte übergeben, aber probiert es am besten selbst mal aus.

<?php
add_filter( 'plugin_action_links_' . $plugin, 'po_plugin_action_links', 10, 3 );
add_filter( 'after_plugin_row_plugin-options.php', 'po_row_meta', 10, 3 );

function po_row_meta( $plugin_file, $plugin_data, $status ) {

    echo  '<tr id="po_options_tr" style="display: none;"><td colspan="4">
          <script>
            jQuery(document).ready( function() {
                var po_options = jQuery( "#po_options" );
                var po_options_tr = jQuery( "#po_options_tr" );

                jQuery( "#po_options_switch" ).click( function(e){
                    e.preventDefault();
                    var display_r = po_options_tr.attr("style");

                    if( ! display_r ){
                        po_options.slideToggle( function () { po_options_tr.attr("style","display:none" ); } );

                    } else {
                        po_options_tr.show();
                        po_options.slideToggle();
                    }
                });
            });
          </script>
          <div id="po_options" style="display:none">';

    var_dump( $plugin_file, $plugin_data, $status );
    echo '</div></td></tr>';
}

function po_plugin_action_links( $array ) {
    $array['opdtions'] = '<a href="#" id="po_options_switch">Einstellungen</a>';
    return $array;
}
?>

Das war es hier von mir, für euch!
Wir sehen uns auf dem WordCamp 2011, René Reimann.

Anmerkung des Bloginhabers Frank

Eine Umsetzung dieser Form kann man in den Screenshots des Plugin WP Maintenance Mode sehen, so dass man sich ein Bild machen kann. Allerdings ist da diese Lösung mittlerweile zu überdenken, da die Optionen im Laufe der Nutzung umfangreicher geworden sind - dies ist durch Wünsche der Nutzer so entstanden; im ersten Ansatz gab es auch nur eine Option.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

// for enabling/disabling theme/plugin editor
define( 'DISALLOW_FILE_EDIT', TRUE );

Die zweite hier vorgestellte Konstante verbietet das Editieren, Modifizieren bzw. Ändern von Dateien aus dem Core, Plugins oder Themes. In dem Zusammenhang sind auch die Menueinträge im Backend nicht sichtbar bzw. nutzbar. Damit ist auch das Update nicht so einfach machbar und Kunden und nicht authentifizierte User sind schnell geblockt.

// Disallow anything that creates, deletes, or edits core, plugin, or theme files.
// Files in uploads are excepted.
define( 'DISALLOW_FILE_MODS', TRUE );

In dem Zusammenhang gibt es zwei weitere Konstanten, die ab und an nützlich sind.
Die erste ist immer mal wieder in den Schlagzeilen, da damit diverse Abfragen konsolidieren. IN diversen Umfeldern ist es aber sehr nützlich, dass alle User der Installation die Möglichkeit haben: ungefiltertes HTML zu schreiben, in allen Aspekten und dies kann ebenso einfach via Konstante realisiert werden.

// Disallow unfiltered_html for all users, even admins and super admins
DISALLOW_UNFILTERED_HTML

Ähnliches gibt es im Umfeld der Uploads.

// Allow uploads of filtered file types to users with administrator role
ALLOW_UNFILTERED_UPLOADS

Die Konstanten gehören in die wp-config.php der Installation.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Das folgenden Beispiel soll es verdeutlichen. Im Standard von WordPress, trotz aktiver Permalinks, sieht die URL zu den beiden Suchbegriffen wordpress und beratung wie folgt aus: bueltge.de/?s=wordpress+beratung&submit=Search. Mit Hilfe einer kleinen Funktion, die den Redirect anspricht, kann die URL angepasst werden. In meinem Fall, mit der zugehörigen nachfolgenden Funktion sieht die URL zu diesen beiden Suchbegriffen dann wie folgt aus: bueltge.de/search/wordpress+beratung.

Die Funktion, die ich einsetze, seht im folgenden Abschnitt. Innerhalb der WP-Funktion wp_redirct lege ich die Ausgabe fest, in dem ich den Begriff search zur home-url der Installation addiere und im Anschluss die Suchbegriffe ergänze. Dies kann man beliebig gestallten und je nach Anforderung so dass beste Ergebnis erziehlen.

function fb_change_search_url_rewrite() {
	if ( is_search() && ! empty( $_GET['s'] ) ) {
		wp_redirect( home_url( "/search/" ) . urlencode( get_query_var( 's' ) ) );
		exit();
	}
}
add_action( 'template_redirect', 'fb_change_search_url_rewrite' );

Die Funktion legt man im besten Falle in einem Plugin ab oder alternativ in der functions.php des Themes. Schöne und verbesserte Lösungen sind wie immer willkommen und das Kommentarfeld steht dazu bereit.

Update
Aus den Kommentaren und Diskussionen ist ebenso eine Lösung entstanden, die explizit eine Lösung via Hook anspricht und so eine frei Benennung ohne Probleme zulässt; nicht desto trotz sollte man sich die Lösung via .htaccess überlegen.

function custom_search_url( $search_rewrite ) {

	if( ! is_array( $search_rewrite ) )
		return $search_rewrite;

	$new_array = array();
	foreach( $search_rewrite as $pattern => $s_query_string ) {
		$new_array[ str_replace( 'search/', 'my-search-url/', $pattern ) ] = $s_query_string;
	}
	$search_rewrite = $new_array;
	unset( $new_array );

	return $search_rewrite;
}
add_filter( 'search_rewrite_rules', 'custom_search_url' );

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

In diesem Artikel möchte ich kurz darstellen, wie man die Inhalte der Custom Post Types in den Loop von WordPress bekommt. Damit ist kein Anspruch auf Vollständigkeit erhoben und die Kommentare stehen euch offen um zu diskutieren, zu kritisieren oder zu ergänzen.

Der Screenshot ist ein Beispiel für die Nutzung der CPT, dabei sind die Plugins Archive und Snippets entstanden, die unterschiedliche Aufgaben haben und mittels CPT recht gut abbildbar waren, insbesondere auf die Anforderungen zugeschnitten, dass man eine Oberfläche hat, die eigenständig berechtigt werden kann, je Objekt je Rolle und parallel die Nutzung von Anwendern erlaubt, die nur die Oberfläche von WP nutzen wollen bzw. kennen.

Im ersten Fall sei die Syntax dargestellt, wie man den Query nutzt und mittels Parameter den Typ des CPT übergibt. In einem Template des Themes sorgt dies dafür, dass nur dieser CPT ausgelesen wird. Alle anderen Parameter des Query bleiben unangetastet.

query_posts( 'post_type=my_post_type' )

Eine weitere Lösung unterscheidet sich im Grunde nur im Stil und dass mehrere CPTs übergeben werden, die in einem Array stecken und damit beachtet werden.

global $query_string;
parse_str( $query_string, $args );
$args['post_type'] = array( 'my_post_type', 'my_second_post_type' );
query_posts( $args );

Um den Loop von WP zu ergänzen und nicht einzuschränken, wird das Array um den Parameter des post_type ergänzt. Via array_merge werden also nur das Array um ein weiteres Array ergänzt.

global $wp_query;
$args = array_merge( $wp_query->query, array( 'post_type' => 'my_post_type' ) );
query_posts( $args );

Im weiteren lassen sich eigene Queries definieren, insbesondere wenn dies in eigenen Variablen nutzen möchte, sei es im Theme oder in Plugins.

$args = array(
	'post_type' => 'my_post_type',
	'post_status' => 'publish',
	'posts_per_page' => -1
);

$posts = new WP_Query( $args );
if ( $posts -> have_posts() ) {
	while ( $posts -> have_posts() ) {
...
	}
}

wp_reset_query();

Als letztes eine Lösung, die insbesondere den Scharm hat, dass man es sauber via Plugin steuern und damit auch bei Tests leicht abschalten kann. Ebenfalls ist die Anwendung in einem Plugin so einfach zu realisieren oder die Erweiterung eines bestehenden Themes via Child Theme oder Plugin. Über den Hook pre_get_posts kann man diverse Sachen des Query anpassen, so auch die CPTs.
Im Beispiel habe ich via Conditional Tags noch diverse Bedingungen drin, so dass man sieht, wie auf die Ausgabe im Frontend reagiert werden kann.

// $this? - example was used in class-structures
// add custom post type to wp loop
add_filter( 'pre_get_posts', array( $this, 'add_to_query') );

// ads to query
function add_to_query( $query ) {

	if ( is_admin() || is_preview() )
		return;

	if ( ! isset( $query -> query_vars['suppress_filters'] ) )
		$query -> query_vars['suppress_filters'] = FALSE;

	// conditional tags for restrictions
	if ( is_home() || is_front_page() && ( FALSE == $query -> query_vars['suppress_filters'] ) ) {
		$query -> set( $this -> my_post_type, array( 'post', $this -> get_textdomain() ) );

	return $query;
}

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Daher hier ein einfache und doch sinnvolle Lösung, um das Suchformular in die Navigation zu holen.
Dabei wird die Standard-Funktion von WordPress für die Suche genutzt - get_search_form(). Sollte dies also auch anderweitig genutzt werden, so gilt auf das Stylesheet zu achten. Ansonsten genügt das folgende Snippet und das Suchformular ist in der Navigation.

Die Funktion und der Aufruf gehört in die functions.php des Themes und die Anpassung des Stylesheet in die jeweilige Datei des Themes, oft die style.css.

function fb_add_search_box ( $items, $args ) {

	// only on primary menu
	if( 'primary' === $args -> theme_location )
		$items .= '<li class="menu-item menu-item-search">' . get_search_form( FALSE ) . '</li>';

	return $items;
}
add_filter( 'wp_nav_menu_items', 'fb_add_search_box', 10, 2 );

Möchte man das Suchformular nur in einer bestimmen Navigation einfügen; insofern man diverse Nav Menus zulässt, dann genügt die Abfrage des Eintrags theme_location aus dem Argumenten-Array. Wenn es sich um das Menu handelt mit dem String n, dann ... - ein Beispiel:
if( 'primary' === $args -> theme_location )

Der Schlüssel für die Abfrage ist im Theme definiert, daher auch gut im Backend zu erkennen, wie der obige Screenshot darstellt. Viel Spaß beim Nutzen und Anpassen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

get_custom_post_type_items( 'my_cpt', 'my_meta_key' );

oder via Array, wenn es sich um mehrere Werte handelt.

get_custom_post_type_items( 'my_cpt', array( 'my_meta_key', 'my_meta_key2' ) );

Die Funktion gibt ein Array zurück, in dem sich alle Inhalte befinden.
Parallel können über den Filter Hook wp_basis_get_cpt_items die Argumente verändert werden, so dass der folgende WordPress Query nach euren Bedürfnissen abläuft.

function get_custom_post_type_items( $custom_post_type, $meta_data_key = FALSE, $args = FALSE ) {

	if ( ! $custom_post_type )
		return NULL;

	$defaults = array(
		'post_type'      => $custom_post_type,
		'post_status'    => 'publish',
		'posts_per_page' => -1,
		'orderby'        => 'post_date',
		'order'          => 'DESC'
	);

	$args = wp_parse_args( $args, apply_filters( 'wp_basis_get_cpt_items', $defaults ) );

	$posts  = new WP_Query($args);
	$return = array();

	if ( $posts -> have_posts() ) {
		while ( $posts -> have_posts() ) {
			$posts -> the_post();
			$post_id  = get_the_ID();
			$sub_post = new stdClass();
			$sub_post -> post_id   = $post_id;
			$sub_post -> title     = get_the_title();
			$sub_post -> permalink = get_permalink($post_id);
			$sub_post -> content   = apply_filters( 'the_content', get_the_content() );
			if ( $meta_data_key && is_string($meta_data_key) ) {
				$meta_value = get_post_meta( $post_id, $meta_data_key, TRUE );
				if ( ! empty($meta_value) )
					$sub_post -> meta_data = $meta_value;
			} elseif ( is_array($meta_data_key) ) {
				foreach ( $meta_data_key as $key ) {
					if ( ! empty($key) ) {
						$meta_value = get_post_meta( $post_id, $key, TRUE );
						if ( ! empty($meta_value) )
							$sub_post -> meta_data[$key] = $meta_value;
					}
				}
			}

			$return[] = $sub_post;
		}
	}

	wp_reset_query();

	return $return;
}

Viel Freude beim Nutzen oder Erweitern.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Innerhalb der kleinen Spielerei sind diverse Anpassungen für Media Queries drin, so dass die Seite auch einen Effekt hat, wenn man die Größe des Browsers ändert bzw. mit verschiedenen Geräten auf die Seite gelangt. Dabei habe ich keinen Wert auf Schönheit gelegt, sondern eher Pragmatismus und Effekthascherei genutzt. So nutze ich Transition via CSS3 um das Verändern etwas animiert zu gestalten und so die Darstellung zu hübschen.
Schaut euch den Code einfach an, entweder direkt auf der Seite oder im Projekt auf github, wo ich alles abgelegt habe.

Für alle, denen noch der Zusammenhang fehlt; bitte einfach die Seite besuchen und den Browser in der Größe ändern; dabei die Ausgabe am oberen Rand beachten. Alternativ dieses kleine Video.

Mir ist klar, dass dies nicht die beste Lösung ist, da Media Queries in jeder erdenklichen Form auftauchen können und die Ausgabe den größten Nutzwert hat, wenn man die Ausgabe der optimierten Größe anpasst. Aber es stellt eine einfache und schnell Lösung dar. Alternativen sind vermutlich via JavaScript denkbar, die das Stylesheet parsen und anhand der gefunden Anweisungen zu Media Queries den Viewport auswerfen – aber diese Form erfordert etwas mehr zeit und Kraft; also schnell überzogen und in meinem Fall ist die vorgestellte Lösung vollkommen ausreichend; durch die Erweiterungen von Frederic sind auch noch andere Viewports eingeflossen und in diesem Zusammenhang habe ich mir bekannte typische Größen und Ausrichtungen integriert – Portrait und Landscape. Alles weitere seht ihr in der angesprochenen debug.css und direkt auf der Seite, die den Source des Stylesheets ausgibt.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Die Funktion kann beliebig erweitert werden, so zum Beispiel mit Abfragen zu Rechten der geloggten User abfragen oder vielfältige andere Anforderungen.

Im ersten Snippet wird die Ausgabe auf dem Frontend immer gefiltert, nur im Backend is_admin() und im Feed is_feed() bleibt alles unangetastet. Der Filter ist im Beispiel auf 15 Minuten gesetzt und diese Werden mit der Einstellung von WordPress abgeglichen, damit die Zeitzone beachtet wird. Die 15 Minuten werden in Sekunden umgerechnet und vom Wert abgezogen.

function publish_later_on_frontend( $where ) {

	if ( is_admin() || is_preview() || is_feed() )
		return $where;

	$offset =  15; // minutes
	$offset = ( get_option( 'gmt_offset' ) * 3600 ) - ( $offset * 60 ); // gmt offset of WP options minus custom time
	$where .= " AND post_date < '" . gmdate( 'Y-m-d H:i:s', ( time() + $offset ) ) . "'";

	return $where;
}
add_filter( 'posts_where', 'publish_later_on_frontend' );

Ein weiteres kurzes Beispiel erlaubt es allen geloggten Usern, die minimal die Rechte zum Lesen current_user_can('read') haben - also Abonnenten, die Inhalte zu lesen. Alle anderen Besucher bekommen die Inhalte 10 Tage später dargestellt.

function publish_later_on_frontend( $where ) {

	if ( is_admin() || is_preview() || is_feed() || current_user_can('read') )
		return $where;

	$offset =  10; // days
	$offset = ( get_option( 'gmt_offset' ) * 3600 ) - ( $offset * 24 * 60 * 60 ); // gmt offset of WP options minus custom time
	$where .= " AND post_date < '" . gmdate( 'Y-m-d H:i:s', ( time() + $offset ) ) . "'";

	return $where;
}
add_filter( 'posts_where', 'publish_later_on_frontend' );

Na - andere Ideen mit der Konstellation? Dann gern in die Kommentare oder via Link hierher verweisen. Ebenso freue ich mich, wenn es Verbesserungen am Code gibt; gerade im Bereich Rechnen mit Zeit gibt es ja viel Spielraum.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

/**
 * Remove a top level admin menu
 *
 * @param string $menu_slug The slug of the menu
 * @return array|bool The removed menu on success, False if not found
 */
remove_menu_page( $menu_slug )

/**
 * Remove an admin submenu
 *
 * @param string $menu_slug The slug for the parent menu
 * @param string $submenu_slug The slug of the submenu
 * @return array|bool The removed submenu on success, False if not found
 */
remove_submenu_page( $menu_slug, $submenu_slug ) {

Damit ist es ein leichtes Menu-Einträge zu entfernen und das Auslesen der Arrays für $menu und $submenu kann entfallen. Bisher musste man die Einträge in diesm Array finden und den entsprechenden Eintrag via unset() aus dem Array nehmen. Alternative waren diverse Konstrukte um den Eintrag auf Grund eines Schlüssel zu finden und zu entfernen - die obigen neuen Funktionen machen dies überflüssig und als Parameterwert wird lediglich die "slug" übergeben, die man im Link bzw. in der URL der Backendseite findet. Ein kleines Beispiel, in dem die Einträge zu den Kommentaren und die Submenu-Seite Diskussion entfernt werden, soll es verdeutlichen.

function fb_remove_menu_entries () {
	// with WP 3.1 and higher
	if ( function_exists( 'remove_menu_page' ) ) {
		remove_menu_page( 'edit-comments.php' );
		remove_submenu_page( 'options-general.php', 'options-discussion.php' );
	} else {
		// unset comments
		unset( $GLOBALS['menu'][25] );
		// unset menuentry Discussion
		unset( $GLOBALS['submenu']['options-general.php'][25] );
	}
}
add_action( 'admin_menu', 'fb_remove_menu_entries' );

Der obige Code stellt eine einfache Lösung dar, entfernt die beiden Einträge und hat ebenso ein Fallback für WordPress, kleiner Version 3.1. Ebenso ist denkbar, dass man das Entfernen mit Rechteabfragen

if ( function_exists( 'remove_menu_page' ) && ! current_user_can( 'manage_options' ) ) {

verbindet und so explizit die Darstellung optimieren kann. Alternativ hilft das Plugin Adminimize und erleichtert diese Aufgabe via Oberfläche.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

<?php
/**
 * Plugin Name: Remove Comments Absolutely
 * Plugin URI: http://bueltge.de/
 * Text Domain: remove_comments_absolute
 * Domain Path: /languages
 * Description: Deactivate comments functions and remove areas absolutely from the WordPress install
 * Author: Frank Bültge
 * Version: 0.0.1
 * Licence: GPLv2
 * Author URI: http://bueltge.de
 * Upgrade Check: none
 * Last Change: 01.06.2011
 */

if ( ! class_exists( 'Remove_Comments_Absolute' ) ) {
	add_action( 'plugins_loaded', array( 'Remove_Comments_Absolute', 'get_object' ) );

	class Remove_Comments_Absolute {

		static private $classobj = NULL;

		/**
		 * Constructor, init on defined hooks of WP and include second class
		 *
		 * @access  public
		 * @since   0.0.1
		 * @uses    add_filter, add_action
		 * @return  void
		 */
		public function __construct () {

			add_filter( 'the_posts', array( $this, 'set_comment_status' ) );

			add_filter( 'comments_open', array( $this, 'close_comments'), 10, 2 );
			add_filter( 'pings_open', array( $this, 'close_comments' ), 10, 2 );

			add_action( 'admin_init', array( $this, 'remove_comments' ) );
			add_filter( 'add_menu_classes', array( $this, 'add_menu_classes' ) );

			add_action( 'admin_head', array( $this, 'remove_comments_areas' ) );

			add_action( 'wp_before_admin_bar_render', array( $this, 'admin_bar_render' ) );
		}

		/**
		 * Handler for the action 'init'. Instantiates this class.
		 *
		 * @access  public
		 * @since   0.0.1
		 * @return  object $classobj
		 */
		public function get_object () {

			if ( NULL === self :: $classobj ) {
				self :: $classobj = new self;
			}

			return self :: $classobj;
		}

		/**
		 * Set the status on posts and pages - is_singular ()
		 *
		 * @access  public
		 * @since   0.0.1
		 * @uses    is_singular
		 * @param   string $posts
		 * @return  string $posts
		 */
		public function set_comment_status ( $posts ) {

			if ( ! empty( $posts ) && is_singular() ) {
				$posts[0]->comment_status = 'closed';
				$posts[0]->post_status = 'closed';
			}

			return $posts;
		}

		/**
		 * Close comments, if open
		 *
		 * @access  public
		 * @since   0.0.1
		 * @param   string | boolean $open
		 * @param   string | integer $post_id
		 * @return  string $posts
		 */
		public function close_comments ( $open, $post_id ) {
			// if not open, than back
			if ( ! $open )
				return $open;

			$post = get_post( $post_id );
			if ( $post -> post_type ) // all post types
				return FALSE;

			return $open;
		}

		/**
		 * Change options for dont use comments
		 * Remove meta boxes on edit pages
		 * Remove support on all post types for comments
		 * Remove menu-entries
		 *
		 * @access  public
		 * @since   0.0.1
		 * @uses    update_option, get_post_types, remove_meta_box, remove_post_type_support
		 * @return  void
		 */
		public function remove_comments () {
			// int values
			foreach ( array( 'comments_notify', 'default_pingback_flag' ) as $option )
				update_option( $option, 0 );
			// string false
			foreach ( array( 'default_comment_status', 'default_ping_status' ) as $option )
				update_option( $option, 'false' );

			// all post types
			// alternative define an array( 'post', 'page' )
			foreach ( get_post_types() as $post_type ) {
				// comment status
				remove_meta_box( 'commentstatusdiv', $post_type, 'normal' );
				// remove trackbacks
				remove_meta_box( 'trackbacksdiv', $post_type, 'normal' );
				// remove all commnts from tabels
				remove_post_type_support( $post_type, 'comments' );
			}
			// remove dashboard meta box for recents comments
			remove_meta_box( 'dashboard_recent_comments', 'dashboard', 'normal' );
			// unset comments
			unset( $GLOBALS['menu'][25] );
			// unset menuentry Discussion
			unset( $GLOBALS['submenu']['options-general.php'][25] );
		}

		/**
		 * Add class for last menu entry with no 20
		 *
		 * @access  public
		 * @since   0.0.1
		 * @param   array string $menu
		 * @return  array string $menu
		 */
		function add_menu_classes ( $menu ) {

			$menu[20][4] .= ' menu-top-last';

			return $menu;
		}

		/**
		 * Remove areas for comments in backend via JS
		 *
		 * @access  public
		 * @since   0.0.1
		 * @return  string with js
		 */
		public function remove_comments_areas () {
			?>
			<script type="text/javascript">
			//<![CDATA[
			jQuery(document).ready( function($) {
				$( '.table_discussion' ).remove();
			});
			//]]>
			</script>
			<?php
		}

		/**
		 * Remove comment entry in Admin Bar
		 *
		 * @access  public
		 * @since   0.0.1
		 * @uses    remove_menu
		 * @return  void
		 */
		public function admin_bar_render () {
			// remove entry in admin bar
			$GLOBALS['wp_admin_bar'] -> remove_menu( 'comments' );
		}

	} // end class

} // end if class exists
?>

Der obige Code ist eher zum Lesen, für die, die direkt am Code sehen wollen, was passiert. Der Download und Hinweise zum aktuellsten Code sind gut auf github zu bekommen bzw. abzulegen: github.com/bueltge/Remove-Comments-Absolutely

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Mein Standpunkt wird sicher sehr WordPress getrieben sein, da ich mich sehr stark in diesem Umfeld bewege und man verzeihe mir die Einschränkung. Aber so spreche ich sicher einen Großteil der Leser meines Blogs an und kann eventuell ein Nachdenke oder gar Umdenken erreichen. Insbesondere ziele ich auf die Anwender ab, die meinen, dass wenn Sie sämtliche Funktionen irgendwo unüberlegt kopieren und in die functions.php des WordPress Themes ziehen, dass Sie eine besonderes tolle Lösung haben. Ein Schnipsel, ein Snippet ist mehr als die Lösung zum Verwenden, es ist die Basis um eine Ziel schneller zu erreichen – es ist nicht die fertige Lösung für die jeweilige Anforderung.

Jeder der viel zeit mit Code verbringt und Lösungen erstellt, insbesondere wenn er dass mehr oder weniger allein tun, schmort im eigenen Saft, eignet sich Eigenarten an und wiederholt Fehler und Denkweisen. Die alltägliche Arbeit kann durch die Nutzung von Schnipseln erleichtern werden - führen sie doch oft zu der gesuchten Lösung und können entweder das Endergebnis sein oder ein Teil eines entstehenden Etwas. Dabei geht vermutlich jeder Entwickler etwas anders vor. Während dem einen die Variante des Schnipsels genügt und er via Copy/Paste die Lösung übernimmt, überdenkt der Andere die Lösung, lernt daraus, verbessert sie oder kommt damit zu einer Lösung im Sinne seiner Anforderung.

Gerade letzteres ist meine Grundidee beim Bereitstellen von Snippets - ich löse diverse Probleme wöchentlich und mehr, trotz der bisher noch immer nebenberuflichen Tätigkeit im Webumfeld. Die Freunde müssen dabei fast täglich ran und eine Lösung finden. Die bereitgestellten Lösungen sollen zum Nachdenken anregen und zur Lösungsfindung beitragen. Je besser man das eigene System kennt, je besser kann man die Anforderungen im Hinblick auf eine gesamtheitliche Lösung für das Basissystem und das Ziel umsetzen. Das pure Copy/Paste-Verhalten sorgt meines Erachtens für Stillstand und unüberlegtes Handeln. Ohne eine Überlegung dazu wird die vorgestellte Lösung implementiert. Insofern versuche ich auch jedes Snippet mit etwas Erläuterung anzureichern und für Verständnis zu sorgen: Warum habe ich so gehandelt? Warum diese Lösung? Man soll sich selbst zum Lernen und dem Verständnis zwingen und so den eigenen Horizont erweitern.

Dabei ist mir ein Austausch sehr wichtig, darum auch öffentlich. Mir ist klar, dass meine Lösung nur im Rahmen meiner Möglichkeiten entstehen kann. Ich bin im Hinblick auf das Web, WordPress und das Programmieren ein Autodidakt, habe nie eine Unterrichtsstunde zu diesen Themen besucht, es sei denn als Unterrichtender. Das Lernen kam immer aus eigenem Antrieb und der Kritik und dem Austausch mit Freunden und Lesern. Das Blog ist sicher eine wunderbare Quelle für den nachweis meines Lernens und gerade meine Plugins für WordPress spiegeln dies wieder; würde ich viele Sachen heute nicht mehr so schreiben, wie noch in den ersten Plugins. Die Lernkurve ist hoffentlich ersichtlich und gerade die vielen Eindrücke, Erfahrungen und Diskussionen machen meine Idee, so glaube ich, im Kundenumfeld so gefragt. Die Erfahrung macht am Ende einen Großteil der Lösung aus.

Code-Schnipsel sind in vielen Blogs zu diversen Themen abgelegt, immer im Hinblick auf den aktuellen Wissenstand und die Zielsetzung des Autors. Darum gehören sie überdacht und auf Gültigkeit geprüft. Sei es um dem eigenen Codingstandard recht zu werden, das explizite Ziel der Anforderung zu erreichen oder eine bessere Lösung zu erstellen.
Ich will Snippets nicht verteufeln, ganz im Gegenteil - teilt eure Ideen und Lösungen, diskutiert sie und seit offen für Verbesserungen! Nur so kann man aus meiner Sicht und Erfahrung zu besseren Lösungen kommen. Fehler sind menschlich - sie sind Teil von uns und wer keine Fehler macht, dem sind einfach die Aufgaben zu gering und die Herausforderung fehlt.

Ich möchte die Leser anregen über das pure Copy/Paste-Verhalten nachzudenken, eventuell umzudenken und beim Veröffentlichen von Schnipseln hier und da einige Worte dazu hinterlegen, so dass der Leser eine Möglichkeit hat, die Lösung zu verstehen und aktiv zu nutzen. Die ständige Verwendung von Schnipseln ohne den geist zerstören die Qualität der Lösung, sorgen für Unsicherheit -, stören die Stabilität im System und machen das Finden von Fehlern schwer.

Im Hinblick auf WordPress und dessen Plugin-API gibt es hier weit mehr auszuholen, aber dann wird es viel und liest das noch jemand? Überdenke gerade im Hinblick auf WordPress die Copy/Paste-Kultur von Snippets, trenne sauber zwischen den Funktionen für das Theme und als Erweiterung für das Gesamtsystem mittels eines Plugins. Thomas hat dazu gerade ein wenig ausgeholt und die Zahl der Plugins in einer WordPress Installation ist keine Aussage zur Qualität! Die Performance des Blogs hängt nicht von der Anzahl der Plugins ab, da gehört weit mehr dazu. Insbesondere die Fehlersuche kann mit Plugins vereinfacht werden, da man über die Oberfläche oder via FTP recht einfach deaktivieren kann - insofern man die einzelnen Funktionen sauber trennt.

Also - auf eine neues im Denken zu Snippets und dessen Verwendung im täglichen Arbeiten im Web oder auch nur im Hobby. Gerade die Applikation und die Arbeit damit wird es danken, der Kunde ebenso.
Bildquelle: Puzzle im Kopf

Hinweis Session zum WordCamp Schweiz

Philip Hetjens wird zu diesem Thema die Session Ein Rant über Snippets auf dem WordCamp am 7. Mai 2011 in der Schweiz halten. Sicher ein schönes Thema zum Diskutieren und Einsichten gewinnen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

PHP Console is extension for Lagger and class PhpConsole, that displays PHP errors/debug messages in Google Chrome console and in notification popups.

Die Aussage trifft es im Grunde auch und bei der ersten Arbeit mit der Erweiterung für den Browser und nach Integration der Klasse sieht man die Ergebnisse sehr schön.
Das Inkludieren der Klasse habe ich via Plugin gelöst, kann natürlich auch statisch in den notwendigen Stellen der entsprechenden Dateien erfolgen.
Über alle Features der Erweiterung kann man sich umfassend auf der Projektseite umsehen; ebenfalls Dokumentationen und Download ist dort zu finden.

Im folgenden einige Einblicke in die Ausgabe und vielleicht macht es Lust auf einen ersten Test oder auch mehr.

Im ersten Screenshot seht ihr die Ausgabe der PHP-Fehler, die in der Console ausgegeben werden, diese kann man gleichzeitig nach dem Load der Seite als Popup bekommen, siehe letzer Screenshot. Dazu gibt es via Kontextmenu diverse Einstellungen der Erweiterung.

Alternativ eine Ausgabe im Log, welche ich via Plugin explizit als Beispiel erzeugt habe. So ist es möglich, dass ihr eure Ausgabe steuert.

Im letzten Screenshot ein Gesamtüberblick, inklusive der popups - man hat eine sehr schöne Ausgabe aller PHP Meldungen und sollte so beim Entwickeln nichts vergessen.

Im folgenden mein kleines Plugin (alternativ bei Github zum Download inkl. aller Dateien und Ordner), wobei ich die Klasse PhpConsole.php der php-Console im Ordner inc ablege. Die Ausgabe im Log der Konsole wird über die Funktion debug() gesteuert; dabei ist es möglich, dass man einen Namen mitgibt und so die Auswertung leichter lesen kann.

<?php
/*
Plugin Name: php-console
Plugin URI: http://bueltge.de/
Text Domain: php-console
Domain Path: /languages
Description: <a href="http://code.google.com/p/php-console/">php-console</a> - Google Chrome extension for displaying PHP errors/exceptions/debug messages in browser console or notification popups
Author: Frank B&uuml;ltge
Version: 0.0.1
Author URI: http://bueltge.de/
Donate URI: http://bueltge.de/wunschliste/
License: GNU v3
Last change: 29.03.2011
*/ 

/* load php-console functionality */
require_once( 'inc/PhpConsole.php' );
PhpConsole::start( TRUE, TRUE, dirname(__FILE__) );

class Wp_Php_Console {

	public function __construct() {

		$this->messages();

		$this->get_contents( 'GNU GENERAL PUBLIC LICENSE' );
	}

	public function messages() {
		global $wpdb, $pagenow;

		debug( $pagenow, 'Var Pagenow' );
		$sql = "SELECT * FROM $wpdb->options";
		debug( $sql, 'sql-options' );
	}

	public function get_contents( $string ) {

		$content = file_get_contents( '../license.txt', NULL, NULL, 0, 100 );
		$pos = strpos( $content, $string );

		debug( $pos , 'Position' );
		if ( ! $pos )
			debug( $content, 'Content' );
	}
}

new Wp_Php_Console();
?>

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

function fb_move_admin_bar() {
    echo '
    <style type="text/css">
    body {
    margin-top: -28px;
    padding-bottom: 28px;
    }
    body.admin-bar #wphead {
       padding-top: 0;
    }
    body.admin-bar #footer {
       padding-bottom: 28px;
    }
    #wpadminbar {
        top: auto !important;
        bottom: 0;
    }
    #wpadminbar .quicklinks .menupop ul {
        bottom: 28px;
    }
    </style>';
}
// on backend area
add_action( 'admin_head', 'fb_move_admin_bar' );
// on frontend area
add_action( 'wp_head', 'fb_move_admin_bar' );

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Der folgende Code gehört in ein Plugin und am besten im den Ordner mu-plugins abgelegt, damit die ID in der Sicht adhoc bereit steht.

class Add_Blog_ID {

	public static function init() {
		$class = __CLASS__ ;

		if ( empty( $GLOBALS[ $class ] ) )
			$GLOBALS[ $class ] = new $class;
	}

	public function __construct() {

		add_filter( 'wpmu_blogs_columns', array( $this, 'get_id' ) );
		add_action( 'manage_sites_custom_column', array( $this, 'add_columns' ), 10, 2 );
		add_action( 'manage_blogs_custom_column', array( $this, 'add_columns' ), 10, 2 );
		add_action( 'admin_footer', array( $this, 'add_style' ) );
	}

	public function add_columns( $column_name, $blog_id ) {

		if ( 'blog_id' === $column_name )
			echo $blog_id;

		return $column_name;
	}

	// Add in a column header
	public function get_id( $columns ) {

		$columns['blog_id'] = __('ID');

		return $columns;
	}

	public function add_style() {

		echo '<style type="text/css" >#blog_id { width:7%; }</style>';
	}
}
add_action( 'init', array( 'Add_Blog_ID', 'init' ) );

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren