Automatisierung von geplanten WordPress-Beiträgen mit ChatGPT und Perl oder Python
In diesem Beitrag zeigen wir Ihnen, wie Sie mithilfe eines Perl- oder Python-Programms automatisch Inhalte von ChatGPT generieren und als geplante Beiträge in Ihrer WordPress-Instanz veröffentlichen. Dies ermöglicht es Ihnen, automatisch generierte Inhalte zu überprüfen und bei Bedarf anzupassen, bevor sie live gehen.
Mit ein paar Anpassungen und Erweiterungen können Sie dieses Skript weiter an Ihre spezifischen Bedürfnisse anpassen und den Workflow automatisieren.
OpenAI API-Schlüssel
Sie benötigen einen API-Schlüssel von OpenAI, um Zugriff auf die ChatGPT-Modelle zu erhalten. Besuchen Sie dazu die OpenAI API-Seite, um Ihren API-Schlüssel zu generieren.
WordPress-Anwendungspasswort
Um Beiträge programmgesteuert in WordPress zu erstellen, müssen Sie ein Anwendungspasswort generieren. Dies können Sie in Ihrem WordPress-Admin-Panel unter “Benutzer” -> “Dein Profil” im Abschnitt “Anwendungspasswörter” tun.
Selbst signierte SSL-Zertifikate
Wenn Ihre WordPress-Installation auf einer privaten Domain mit selbst signierten SSL-Zertifikaten gehostet wird, stellt das Programm sicher, dass diese akzeptiert werden.
Funktionsweise des Programms
Das Programm liest die Konfigurationsdaten aus einer JSON-Datei (config.json). Diese Datei enthält die notwendigen Zugangsdaten und API-URLs. Das Programm führt folgende Schritte aus:
Laden der Konfiguration
Die Zugangsdaten und URLs werden aus der config.json-Datei geladen.
Generieren des Inhalts mit ChatGPT
Ein Prompt wird an die OpenAI API gesendet, und das Modell gpt-4 generiert eine Antwort, die als Inhalt des WordPress-Beitrags verwendet wird.
Planen des Beitrags in WordPress
Der generierte Inhalt wird als neuer Beitrag in WordPress erstellt und so geplant, dass er in genau 24 Stunden veröffentlicht wird. Dadurch haben Sie genügend Zeit, den Beitrag zu überprüfen und bei Bedarf zu bearbeiten.
Fehlerbehandlung und Debugging
Das Programm enthält Mechanismen zur Fehlerbehandlung und gibt detaillierte Fehlermeldungen aus, um die Diagnose und Behebung von Problemen zu erleichtern.
JSON-Konfigurationsdatei
nano config.json
{
"openai_api_key": "YOUR_CORRECT_OPENAI_API_KEY",
"openai_api_url": "https://api.openai.com/v1/chat/completions",
"openai_model": "gpt-4",
"wordpress_url": "https://wordpress.lan/wp-json/wp/v2/posts",
"wordpress_user": "YOUR_WORDPRESS_USERNAME",
"wordpress_password": "YOUR_APPLICATION_PASSWORD"
}Perl-Skript
nano chatgpt-wordpress.pl
#!/usr/bin/perl
use strict;
use warnings;
use utf8;
use open ':std', ':encoding(UTF-8)';
use LWP::UserAgent;
use HTTP::Request::Common qw(POST);
use JSON;
use MIME::Base64;
use IO::Socket::SSL;
use File::Slurp;
use POSIX qw(strftime);
# Konfigurationsdatei laden
my $config_file = 'config.json';
my $config_content = read_file($config_file);
my $config = decode_json($config_content);
# OpenAI API-Details
my $openai_api_key = $config->{openai_api_key};
my $openai_api_url = $config->{openai_api_url};
my $openai_model = $config->{openai_model};
# WordPress API-Details
my $wordpress_url = $config->{wordpress_url};
my $wordpress_user = $config->{wordpress_user};
my $wordpress_password = $config->{wordpress_password};
# Prompt an ChatGPT senden
sub get_chatgpt_response {
my ($prompt, $api_key, $api_url, $model) = @_;
my $ua = LWP::UserAgent->new(
ssl_opts => { verify_hostname => 0, SSL_verify_mode => IO::Socket::SSL::SSL_VERIFY_NONE }
);
my $response = $ua->request(POST $api_url,
Content_Type => 'application/json',
Authorization => "Bearer $api_key",
Content => encode_json({
model => $model,
messages => [{role => "user", content => $prompt}],
max_tokens => 1000,
})
);
if ($response->is_success) {
my $content = decode_json($response->decoded_content);
return $content->{choices}->[0]->{message}->{content};
} else {
warn "Error contacting OpenAI API: " . $response->status_line . "\n" . $response->decoded_content;
return "Dies ist ein Platzhaltertext, da die API-Quota überschritten wurde.";
}
}
# Beitrag auf WordPress veröffentlichen
sub publish_to_wordpress {
my ($title, $content, $status, $url, $user, $password) = @_;
my $ua = LWP::UserAgent->new(
ssl_opts => { verify_hostname => 0, SSL_verify_mode => IO::Socket::SSL::SSL_VERIFY_NONE }
);
my $encoded_auth = encode_base64("$user:$password", '');
# Veröffentlichungsdatum in 24 Stunden
my $publish_date = strftime("%Y-%m-%dT%H:%M:%S", localtime(time + 24 * 60 * 60));
my $response = $ua->request(POST $url,
Content_Type => 'application/json',
Authorization => "Basic $encoded_auth",
Content => encode_json({
title => $title,
content => $content,
status => 'future',
date => $publish_date,
})
);
if ($response->is_success) {
my $result = decode_json($response->decoded_content);
return $result->{link};
} else {
die "Error contacting WordPress API: " . $response->status_line . "\n" . $response->decoded_content;
}
}
# Beispielaufruf
my $prompt = "Erkläre die Vorteile von Perl für die Webentwicklung.";
my $response = get_chatgpt_response($prompt, $openai_api_key, $openai_api_url, $openai_model);
my $title = "ChatGPT-Erklärung zu Perl";
my $status = "future"; # Geplanter Beitrag
my $result_link = publish_to_wordpress($title, $response, $status, $wordpress_url, $wordpress_user, $wordpress_password);
print "Beitrag veröffentlicht: $result_link\n";Python-Script
nano chatgpt-wordpress.py
import requests
import json
from base64 import b64encode
from datetime import datetime, timedelta
import urllib3
# Warnungen für unsichere SSL-Verbindungen unterdrücken
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
# Konfigurationsdatei laden
with open('config.json', 'r') as f:
config = json.load(f)
# OpenAI API-Details
openai_api_key = config['openai_api_key']
openai_api_url = config['openai_api_url']
openai_model = config['openai_model']
# WordPress API-Details
wordpress_url = config['wordpress_url']
wordpress_user = config['wordpress_user']
wordpress_password = config['wordpress_password']
# Prompt an ChatGPT senden
def get_chatgpt_response(prompt, api_key, api_url, model):
headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {api_key}'
}
data = {
'model': model,
'messages': [{'role': 'user', 'content': prompt}],
'max_tokens': 1000
}
try:
response = requests.post(api_url, headers=headers, json=data)
response.raise_for_status()
content = response.json()
return content['choices'][0]['message']['content']
except requests.exceptions.RequestException as e:
print(f"Error contacting OpenAI API: {e}")
return "Dies ist ein Platzhaltertext, da die API-Quota überschritten wurde."
# Beitrag auf WordPress veröffentlichen
def publish_to_wordpress(title, content, status, url, user, password):
auth_str = f'{user}:{password}'
encoded_auth = b64encode(auth_str.encode()).decode()
headers = {
'Content-Type': 'application/json',
'Authorization': f'Basic {encoded_auth}'
}
# Veröffentlichungsdatum in 24 Stunden
publish_date = (datetime.now() + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')
data = {
'title': title,
'content': content,
'status': status,
'date': publish_date
}
try:
response = requests.post(url, headers=headers, json=data, verify=False) # Zertifikatsprüfung deaktiviert
response.raise_for_status()
result = response.json()
return result['link']
except requests.exceptions.RequestException as e:
print(f"Error contacting WordPress API: {e}")
return None
# Beispielaufruf
prompt = "Erkläre die Vorteile von Python für die Webentwicklung."
response = get_chatgpt_response(prompt, openai_api_key, openai_api_url, openai_model)
title = "ChatGPT-Erklärung zu Python"
status = "future" # Geplanter Beitrag
result_link = publish_to_wordpress(title, response, status, wordpress_url, wordpress_user, wordpress_password)
if result_link:
print(f"Beitrag veröffentlicht: {result_link}")
else:
print("Beitrag konnte nicht veröffentlicht werden.")