Archiv der Kategorie: PHP

Eine simple API für WordPress, Teil 4

Wir wissen jetzt, wie wir mit Hilfe unserer kleinen API einen Artikel anlegen und wie wir ihn mit einem Bild versorgen. Nun fügen wir einige Metadaten hinzu. Dazu benötigen wird die Funktion “add_post_meta“. Diese verlangt folgende Parameter:

  • post_id – Die eindeutige Artikel-ID aus Teil 2
  • meta_key – Der Name des Metadaten-Feldes
  • meta_value – Der Wert des Metadaten-Feldes

Wir packen also wieder einen Befehlsaufruf für unseren Server zusammen:

$postdata_array=array(
	'function' => 'add_post_meta', 
	'post_id' => $parent_post_id,
	'meta_key' => 'Geschmack',
	'meta_value' => 'sauer'
	);

Und natürlich müssen wir auch unseren Server wieder ein wenig ergänzen.

if ($postdata_array['function']=='add_post_meta') {
	print add_post_meta($postdata_array['post_id'], $postdata_array['meta_key'], $postdata_array['meta_value']);
}

Diese 3 Zeilen erweitern unseren Server um die Fähigkeit, mit Hilfe der Funktion “add_post_meta” Artikel mit beliebigen Metadaten zu versorgen.

Und so sieht dann das neue benutzerdefinierte Feld aus.

Zusammenfassung

Server

<?php
define('WP_USE_THEMES', false);
header('Content-Type: text/html; charset=utf-8');
if (count($_GET)>0) $postdata_array=unserialize(array_shift($_GET));
if (count($_POST)>0) $postdata_array=unserialize(array_shift($_POST));
require('../wp-load.php');

if ($postdata_array['function']=='wp_insert_post') {
	print wp_insert_post($postdata_array['wp_post_array']);
}

if ($postdata_array['function']=='wp_insert_attachment') {
	$filetype = wp_check_filetype( basename( $postdata_array['file'] ), null );
	$wp_upload_dir = wp_upload_dir();
	$attachment = array(
		'guid'           => $wp_upload_dir['url'] . '/' . basename( $postdata_array['file']), 
		'post_mime_type' => $filetype['type'],
		'post_title'     => preg_replace( '/\.[^.]+$/', '', basename( $postdata_array['file'] ) ),
		'post_content'   => '',
		'post_status'    => 'inherit'
	);
	$attach_id = wp_insert_attachment( $attachment, $postdata_array['file'], $postdata_array['parent_post_id'] );
	require_once( ABSPATH . 'wp-admin/includes/image.php' );
	$attach_data = wp_generate_attachment_metadata( $attach_id, $postdata_array['file'] );
	wp_update_attachment_metadata( $attach_id, $attach_data );
	set_post_thumbnail( $postdata_array['parent_post_id'], $attach_id );	
}

if ($postdata_array['function']=='add_post_meta') {
	print add_post_meta($postdata_array['post_id'], $postdata_array['meta_key'], $postdata_array['meta_value']);
}

exit();
?>

Client

<?php
function call_server($postdata_array) {
	$username='mueller';
	$password='geheim';
	$serverurl='http://domain.tld/maschine/';

	$postdata = http_build_query(
		array(
			'postdata_string' => serialize($postdata_array)
		)
	);

	$auth = base64_encode($username.':'.$password);
	$header = array("Authorization: Basic $auth",
		'Content-type: application/x-www-form-urlencoded'
		);

	$opts = array('http' =>
		array(
			'method'  => 'POST',
			'header'  => $header,
			'content' => $postdata,
			'timeout' => 5000,  //5 Sekunden
		)
	);

	$context = stream_context_create($opts);
	return file_get_contents($serverurl, false, $context);
}


$postdata_array=array(
	'function' => 'wp_insert_post', 
	'wp_post_array' => array(
		'post_content' => '<p>Das ist ein <b>Test äöüß</b><br>Und noch eine Zeile</p>',
		'post_title' => 'Meine erste Überschrift',
		'post_status' => 'publish',
		'post_category' => null
		)
	);
$parent_post_id = call_server($postdata_array);

# FTP Upload des Bildes
$ftp_server='domain.tld';
$ftp_user='john';
$ftp_password='secret007';
$remote_folder='/var/www/domain.tld/wp-content/uploads/maschine/';
$local_folder='/var/upload/bilder/';
$file_name='bild.jpg';

$conn_id = ftp_connect($ftp_server);
ftp_login($conn_id, $ftp_user, $ftp_password);
ftp_put($conn_id, $remote_folder.$file_name, $local_folder.$file_name, FTP_BINARY);
ftp_close($conn_id);

$postdata_array=array(
	'function' => 'wp_insert_attachment', 
	'file' => $remote_folder.$file_name,
	'parent_post_id' => $parent_post_id
	);

print call_server($postdata_array);

# Metadaten hinzufügen
$postdata_array=array(
	'function' => 'add_post_meta', 
	'post_id' => $parent_post_id,
	'meta_key' => 'Geschmack',
	'meta_value' => 'sauer'
	);
	
call_server($postdata_array);

exit();
?>

 

Eine simple API für WordPress, Teil 3

Kommen wir nun zum wichtigen Thema: Wie füge ich dem Artikel ein Bild bei?

Auch das wird in vielen Beiträgen im Internet gerne angerissen, aber mal ein paar schnelle, praktikable Lösungen werden selten präsentiert. Dabei ist es nicht so schwer, wenn man weiß, was zu tun ist.

Der Ablauf

Im Grunde müssen folgende Schritte abgearbeitet werden:

  1. Wir erzeugen einen Artikel und merken uns die ID (siehe Teil 2)
  2. Wir laden ein Bild per FTP auf den WordPress-Server
  3. Wir verbinden Artikel und Bild mit Hilfe der Funktionen: wp_generate_attachment_metadatawp_insert_attachment und set_post_thumbnail

Damit das funktioniert, müssen wir unseren Server gleich zweimal bemühen: Beim Erzeugen des Artikels und beim Verbinden des Bildes mit ersterem.

Der Upload per FTP

Keine Angst, das ist per PHP einfacher, als man denkt.

Zunächst benötigen wir auf dem WordPress-Blog einen Zielordner. Den kann man per Konsole oder FTP anlegen:

md /var/www/domain.tld/wp-content/uploads/maschine/

Auf diesen Server werden die Bilder (oder was immer man später mit den Artikeln verknüpfen möchte: ZIP-File, E-Book, PDF etc.) zwischengespeichert. Man sollte darauf achten, dass die Dateinamen dabei immer einzigartig sind, denn sonst werden sie gnadenlos überschrieben. Erreichen kann man das z.B. durch eine Ergänzung mit einer Time-id und einer laufenden Nummer.

Wir erweitern den Client um einige Zeilen:

$ftp_server='domain.tld';
$ftp_user='john';
$ftp_password='secret007';
$remote_folder='/var/www/domain.tld/wp-content/uploads/maschine/';
$local_folder='/var/upload/bilder/';
$file_name='bild.jpg';

$conn_id = ftp_connect($ftp_server);
ftp_login($conn_id, $ftp_user, $ftp_password);
ftp_put($conn_id, $remote_folder.$file_name, $local_folder.$file_name, FTP_BINARY);
ftp_close($conn_id);

Damit wird die Datei “bild.jpg” vom lokalen Verzeichnis “/var/upload/bilder/” auf das entfernte Verzeichnis “/var/www/domain.tld/wp-content/uploads/maschine/” des Servers “domain.tld” kopiert. Wenn Sie nicht wissen, wie das entfernte Verzeichnis lautet, fragen Sie ihren Provider.

Bevor wir nun an den Client gehen, packen wir dessen Kernaufgabe in eine Funktion, damit wir sie mehrfach benützen können.

function call_server($postdata_array) {
	$username='mueller';
	$password='geheim';
	$serverurl='http://domain.tld/maschine/';

	$postdata = http_build_query(
		array(
			'postdata_string' => serialize($postdata_array)
		)
	);

	$auth = base64_encode($username.':'.$password);
	$header = array("Authorization: Basic $auth",
		'Content-type: application/x-www-form-urlencoded'
		);

	$opts = array('http' =>
		array(
			'method'  => 'POST',
			'header'  => $header,
			'content' => $postdata,
			'timeout' => 5000,  //5 Sekunden
		)
	);

	$context = stream_context_create($opts);
	return file_get_contents($serverurl, false, $context);
}

Diese Funktion sendet ein Array an unseren Server und gibt dessen Antwort wieder zurück.

Die Aufgaben des Servers werden jetzt erweitert. Er kann nicht nur Artikel anlegen, sondern auch Bilder verarbeiten. Das geschieht durch folgende Zeilen:

$filetype = wp_check_filetype( basename( $postdata_array['file'] ), null );
$wp_upload_dir = wp_upload_dir();
$attachment = array(
	'guid'           => $wp_upload_dir['url'] . '/' . basename( $postdata_array['file']), 
	'post_mime_type' => $filetype['type'],
	'post_title'     => preg_replace( '/\.[^.]+$/', '', basename( $postdata_array['file'] ) ),
	'post_content'   => '',
	'post_status'    => 'inherit'
);
$attach_id = wp_insert_attachment( $attachment, $postdata_array['file'], $postdata_array['parent_post_id'] );
require_once( ABSPATH . 'wp-admin/includes/image.php' );
$attach_data = wp_generate_attachment_metadata( $attach_id, $postdata_array['file'] );
wp_update_attachment_metadata( $attach_id, $attach_data );
set_post_thumbnail( $postdata_array['parent_post_id'], $attach_id );

Zeile 1 ermittelt den Mime-Type der Datei (hier: “image/jpeg”), das Array mit den Meta-Daten (Titel, eindeutiger Bezeichner etc.) wird automatisch gefüllt. Natürlich können Sie den Titel des Bildes auch aus den eigenen Daten erzeugen.

Zeile 10 fügt dann das eben hochgeladene Bild der Mediendatenbank des Blogs hinzu. Von nun an finden Sie das Bild dort, aber es ist noch nicht mit einem Artikel verbunden. Das erledigen wir gleich.

Zeile 12 versorgt das Bild in der Mediendatenbank mit den soeben festgelegten Metadaten und legt die einzelnen Vorschaubilder in den verschiedenen Größen an, die in den Medien-Einstellungen von WordPress festgelegt sind.

Zeile 14 macht die Magie: Das Bild wird mit dem Artikel verbunden.

Zusammengefasst

Der Server

<?php
define('WP_USE_THEMES', false);
header('Content-Type: text/html; charset=utf-8');
if (count($_GET)>0) $postdata_array=unserialize(array_shift($_GET));
if (count($_POST)>0) $postdata_array=unserialize(array_shift($_POST));
require('../wp-load.php');

if ($postdata_array['function']=='wp_insert_post') {
	print wp_insert_post($postdata_array['wp_post_array']);
}

if ($postdata_array['function']=='wp_insert_attachment') {
	$filetype = wp_check_filetype( basename( $postdata_array['file'] ), null );
	$wp_upload_dir = wp_upload_dir();
	$attachment = array(
		'guid'           => $wp_upload_dir['url'] . '/' . basename( $postdata_array['file']), 
		'post_mime_type' => $filetype['type'],
		'post_title'     => preg_replace( '/\.[^.]+$/', '', basename( $postdata_array['file'] ) ),
		'post_content'   => '',
		'post_status'    => 'inherit'
	);
	$attach_id = wp_insert_attachment( $attachment, $postdata_array['file'], $postdata_array['parent_post_id'] );
	require_once( ABSPATH . 'wp-admin/includes/image.php' );
	$attach_data = wp_generate_attachment_metadata( $attach_id, $postdata_array['file'] );
	wp_update_attachment_metadata( $attach_id, $attach_data );
	set_post_thumbnail( $postdata_array['parent_post_id'], $attach_id );	
}


exit();
?>

Der Client

<?php
function call_server($postdata_array) {
	$username='mueller';
	$password='geheim';
	$serverurl='http://domain.tld/maschine/';

	$postdata = http_build_query(
		array(
			'postdata_string' => serialize($postdata_array)
		)
	);

	$auth = base64_encode($username.':'.$password);
	$header = array("Authorization: Basic $auth",
		'Content-type: application/x-www-form-urlencoded'
		);

	$opts = array('http' =>
		array(
			'method'  => 'POST',
			'header'  => $header,
			'content' => $postdata,
			'timeout' => 5000,  //5 Sekunden
		)
	);

	$context = stream_context_create($opts);
	return file_get_contents($serverurl, false, $context);
}


$postdata_array=array(
	'function' => 'wp_insert_post', 
	'wp_post_array' => array(
		'post_content' => '<p>Das ist ein <b>Test äöüß</b><br>Und noch eine Zeile</p>',
		'post_title' => 'Meine erste Überschrift',
		'post_status' => 'publish',
		'post_category' => null
		)
	);
$parent_post_id = call_server($postdata_array);

# FTP Upload des Bildes
$ftp_server='domain.tld';
$ftp_user='john';
$ftp_password='secret007';
$remote_folder='/var/www/domain.tld/wp-content/uploads/maschine/';
$local_folder='/var/upload/bilder/';
$file_name='bild.jpg';

$conn_id = ftp_connect($ftp_server);
ftp_login($conn_id, $ftp_user, $ftp_password);
ftp_put($conn_id, $remote_folder.$file_name, $local_folder.$file_name, FTP_BINARY);
ftp_close($conn_id);

$postdata_array=array(
	'function' => 'wp_insert_attachment', 
	'file' => $remote_folder.$file_name,
	'parent_post_id' => $parent_post_id
	);

print call_server($postdata_array);

exit();
?>

Das war ja nicht so schwer, wenn man weiß, wie es geht – aber das gilt wohl für alles im Leben. Im nächsten Schritt lernen wir, unseren Artikel nachträglich mit Daten anzureichern.

Eine simple API für WordPress, Teil 2

Wir kommen nun dazu, mit Hilfe unserer kleinen API einen WordPress-Artikel anzulegen.

Dazu müssen wir uns kurz mit den internen Funktionen beschäftigen, die WordPress für dieses Unterfangen zur Verfügung stellt.

Es ist zunächst die Funktion “wp_insert_post“.

wp_insert_post( array $postarr, bool $wp_error = false )

Mit ihrer Hilfe kann man Artikel (oder auch Seiten) anlegen und bearbeiten.

Es gibt viele Parameter. Wir betrachten zunächst die wichtigsten:

  • post_content – der Inhalt des Artikels
  • post_title – die Überschrift des Artikels
  • post_status – der Status des Artikels und

Stellen wir uns ein simples Array zusammen:

$postarr => array(
	'post_content' => '<p>Das ist ein <b>Test äöüß</b><br>Und noch eine Zeile</p>',
	'post_title' => 'Meine erste Überschrift',
	'post_status' => 'publish'
	)

Die Werte sollten sich von selbst erklären. Ich empfehle, wenn immer möglich beim Testen Umlaute zu nutzen, um später keine bösen Überraschungen zu erleben.

Ich setze “post_status” auf “publish“, da ich die Artikel sofort veröffentliche. Wer aber noch händisch nachkontrollieren oder erstmal sichergehen möchte, der setzt “post_status” auf “draft“.

Der neue Client

Der Client muss entsprechend angepasst werden.

<?php
$username='mueller';
$password='geheim';
$serverurl='http://domain.tld/maschine/';
$postdata_array=array(
	'function' => 'wp_insert_post', 
	'wp_post_array' => array(
		'post_content' => '<p>Das ist ein <b>Test äöüß</b><br>Und noch eine Zeile</p>',
		'post_title' => 'Meine erste Überschrift',
		'post_status' => 'publish'
		)
	);

$postdata = http_build_query(
	array(
		'postdata_string' => serialize($postdata_array)
	)
);

$auth = base64_encode($username.':'.$password);
$header = array("Authorization: Basic $auth",
	'Content-type: application/x-www-form-urlencoded'
	);

$opts = array('http' =>
	array(
		'method'  => 'POST',
		'header'  => $header,
		'content' => $postdata,
		'timeout' => 5000,  //5 Sekunden
	)
);

$context  = stream_context_create($opts);
$result = file_get_contents($serverurl, false, $context);

header('Content-Type: text/html; charset=utf-8');
print $result;
exit();
?>

Der Aufbau hat sich nicht sehr gegenüber Teil 1 verändert.

Der neue Server

Beim Server hat sich ein wenig mehr getan.

<?php
define('WP_USE_THEMES', false);
header('Content-Type: text/html; charset=utf-8');
if (count($_GET)>0) $postdata_array=unserialize(array_shift($_GET));
if (count($_POST)>0) $postdata_array=unserialize(array_shift($_POST));

require('../wp-load.php');

if ($postdata_array['function']=='wp_insert_post') {
	print wp_insert_post($postdata_array['wp_post_array']);
}
exit();

Wir müssen nun die Verbindung unseres Servers zu WordPress herstellen. Das passiert ganz einfach durch die Zeile:

require('../wp-load.php');

Die Datei “wp-load.php” die sich im Hauptverzeichnis des Blogs befindet, stellt automatisch alle Daten und Komponenten zur Verfügung, die wir für den Umgang mit WordPress benötigen.

Die Zeile:

define('WP_USE_THEMES', false);

Sorgt noch dafür, dass wir keine Komponenten laden, die lediglich für das Frontend des Blogs benötigt werden.

Der Rest dürfte sich von selbst erklären. Interessant ist Zeile 10, in der der eigentliche Befehl zum Anlegen ausgeführt wird und als Ergebnis die ID des neuen Artikels (WordPress-Jargon: Post) an den Client zurückgegeben wird. Diese ID ist wichtig und sollte irgendwo auf Seiten des Clients gespeichert werden, denn später werden wir sie benötigen, um Artikel zu korrigieren, zu löschen oder mit anderen Daten anzureichern. Die ID ist immer eindeutig und wird niemals doppelt vergeben.

Rufen wir den Client auf:

http://localhost/client.php

Das Ergebnis gibt uns die ID 4025 zurück.

Und schauen wir mal ins Backend des Blogs.

Voilà – Das ist unser Artikel.

Bis dahin war es noch nicht ganz so schwer. Bisher hatten wir nur die Pflicht, jetzt folgt die Kür. Im nächsten Teil werde ich zeigen, wie man dem Artikel auch ein Bild zuordnet.

ssdeep Funktionen für PHP installieren

Wer folgende ssdeep-PHP-Funktionen

  • ssdeep_fuzzy_compare
  • ssdeep_fuzzy_hash_filename
  • ssdeep_fuzzy_hash

nutzen möchte, der muss sie zunächst für PHP installieren. Dazu werden verschiedene Pakete und Bibliotheken benötigt. Ich skizziere hier einmal den Schnelldurchgang.

wget http://downloads.sourceforge.net/project/ssdeep/ssdeep-2.13/ssdeep-2.13.tar.gz
tar zxvf ssdeep-2.13.tar.gz
cd ssdeep-2.13
./configure
make
sudo make install
ssdeep -h # test
sudo pecl install ssdeep
sudo sh -c "echo 'extension=ssdeep.so' >> /etc/php5/mods-available/ssdeep.ini"
sudo php5enmod ssdeep
sudo service apache2 restart

Die Funktionen selbst sind hier beschrieben: http://php.net/manual/en/ref.ssdeep.php