Wenn Sie einen WooCommerce-Shop betreiben, wissen Sie, wie wichtig effizientes und zuverlässiges Management ist. Unsere innovative Windows-Software wurde speziell entwickelt, um Ihre Verwaltung zu vereinfachen und Ihre Produktivität zu steigern. Mit einer Vielzahl von Funktionen, die speziell auf die Bedürfnisse von WooCommerce-Shop-Betreibern zugeschnitten sind, bietet unsere Software alles, was Sie benötigen, um Ihren Shop nahtlos zu verwalten.

Bestellungen verwalten leicht gemacht

Unsere Software bietet eine umfassende Übersicht über alle Bestellungen in Ihrem Shop. Sie können Bestellungen nach Kundenname, Order-ID oder anderen Daten filtern und sofort aktualisieren. Mit dem intelligenten Stornierungssystem können Sie Bestellungen und einzelne Produkte sicher und effizient stornieren. Dank der automatischen Aktualisierungsfunktion bleiben Ihre Daten immer auf dem neuesten Stand. Weitere Highlights umfassen:

• Manuelle und automatische Rückerstattungen
• Bestellnotizen einsehen und E-Mails an Kunden senden
• Druck- und Kopierfunktionen für Bestellungen

Produktmanagement auf höchstem Niveau

Verwalten Sie alle Ihre Produkte, von einfachen bis hin zu variablen Produkten, direkt über unsere Software. Bearbeiten Sie Preise, Namen, Lagerbestände und SEO-Daten mühelos. Unsere Software unterstützt Sie dabei, Produktbilder hochzuladen und zu ändern und bietet eine eigene Browserfunktion zum Ansehen Ihrer Produkte. Durch die Filter- und Aktualisierungsfunktionen behalten Sie stets den Überblick und können sofort auf Änderungen reagieren.

Kunden- und Benutzerverwaltung optimiert

Die Verwaltung von Nutzern und Kunden war noch nie so einfach. Mit unserer Software können Sie alle Benutzerinformationen einsehen und bearbeiten, einschließlich Name, Rolle, E-Mail und Rechnungsdaten. Sicherheitsfunktionen verhindern unbefugte Änderungen an Administratoren. Versenden Sie Passwortrücksetzungs-E-Mails und individuelle Nachrichten direkt aus der Software.

Effizientes Gutschein-Management

Unsere Software ermöglicht es Ihnen, Gutscheine zu verwalten, zu bearbeiten und zu erstellen. Filtern Sie Gutscheine nach Code, E-Mail oder anderen Daten und aktualisieren Sie sie automatisch. Sie können Gutscheine löschen und neue mit denselben Daten erstellen, was Ihre Marketingstrategien erheblich vereinfacht.

Bewertungen im Griff

Behalten Sie alle Bewertungen Ihrer Produkte im Blick. Filtern Sie Bewertungen nach Produkt, E-Mail oder anderen Daten und bearbeiten Sie sie direkt in der Software. Mit der automatischen Aktualisierungsfunktion sind Ihre Daten stets aktuell, und Sie können unerwünschte Bewertungen einfach löschen.

Umfassende Statistikfunktionen

Verfolgen Sie Ihre Verkaufsleistung mit unserem Sales over Time-Diagramm, das die Verkäufe der letzten 12 Monate anzeigt. Drucken Sie Diagramme aus und behalten Sie den Überblick über Ihre Geschäftsentwicklung.

Leistungsstarke Tools für mehr Effizienz

Unsere Software bietet eine Reihe von Tools, die speziell entwickelt wurden, um Ihre Arbeit zu erleichtern:

• CSV Produkt Import: Erstellen Sie Produkte durch CSV-Dateien, validieren Sie Daten vor dem Upload und unterstützen Sie unbegrenzte Produktmengen.
• Massen-Preis-Veränderung: Passen Sie Preise von allen Produkten im Shop an, entweder in Euro oder Prozent.
• Massen-Email-Funktionen: Versenden Sie E-Mails an alle Nutzer oder Kunden, ähnlich wie bei einer Newsletter-Funktion.
• Shop Nachrichten: Platzieren und aktualisieren Sie individuelle Nachrichten auf Ihrer Webseite mit Shortcodes.
• Zahlungseinstellungen: Aktivieren oder deaktivieren Sie Zahlungsmöglichkeiten mit einem Klick.
• Update Plugins und WordPress: Aktualisieren Sie Plugins und die WordPress-Version direkt über die Software.

Warum unsere Software?

Unsere Software ist mehr als nur ein Verwaltungswerkzeug. Sie ist Ihr Partner für ein effizientes und erfolgreiches WooCommerce-Management. Mit einer benutzerfreundlichen Oberfläche und robusten Funktionen optimieren Sie Ihre Geschäftsprozesse und sparen wertvolle Zeit. Machen Sie sich das Leben leichter und steigern Sie Ihre Produktivität – mit unserer maßgeschneiderten Lösung für WooCommerce.

Lassen Sie sich diese Chance nicht entgehen! Testen Sie unsere Software und erleben Sie, wie einfach und effizient das Management Ihres WooCommerce-Shops sein kann. Kontaktieren Sie uns noch heute und erfahren Sie mehr darüber, wie unsere Software Ihnen helfen kann, Ihre Geschäftsziele zu erreichen.
 

Kostenloser Demo Download, mehr Informationen und Lizenzschlüssel für Vollversion kaufen:
https://shop.homepage-nach-preis.de/produkt/hnp-windows-manager-fuer-woocommerce/

Der Beitrag WooCommerce für Windows – Software von HNP erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Die Funktion zur Registrierung der REST-API-Route wird verwendet, um einen neuen Endpunkt in WordPress hinzuzufügen. Dieser Endpunkt ermöglicht es, externe Anfragen an WordPress zu senden und eine Antwort zu erhalten.

Schritte der Registrierung:

Hook zur Initialisierung der REST-API: Mit add_action('rest_api_init', function () { … }); wird eine anonyme Funktion registriert, die während der Initialisierung der REST-API aufgerufen wird.
Definition der Route: Innerhalb dieser anonymen Funktion wird register_rest_route aufgerufen, um die Route zu definieren.
Namespace: 'hnp_api_firewall/v1' legt den Namespace fest, der als Versionierung der API dient.
Route: '/api' ist der spezifische Endpunkt innerhalb des Namespace.
Optionen: Ein Array von Optionen, darunter:
Methode: 'methods' => 'POST' spezifiziert, dass die Route nur POST-Anfragen akzeptiert.
Callback: 'callback' => 'hnp_api_firewall_callback' gibt die Funktion an, die aufgerufen wird, wenn die Route erreicht wird.
Berechtigung: 'permission_callback' => 'hnp_api_firewall_combined_permissions' bestimmt die Funktion, die die Berechtigungen für den Zugriff auf die Route überprüft.

Kombinierte Berechtigungs- und Blockierungslogik

Die Funktion hnp_api_firewall_combined_permissions dient dazu, die Berechtigungen und Blockierungslogik zu kombinieren. Sie wird aufgerufen, bevor die Haupt-Callback-Funktion ausgeführt wird, um sicherzustellen, dass nur berechtigte Anfragen zugelassen werden.

Schritte der Berechtigungsprüfung:

IP-Überprüfung: Die IP-Adresse des Anfragenden wird überprüft, um festzustellen, ob sie blockiert ist.
Wenn die IP-Adresse blockiert ist und die Blockierungsdauer noch nicht abgelaufen ist, wird der Zugriff verweigert.
Wenn die Blockierungsdauer abgelaufen ist, wird die IP-Adresse entsperrt und die Blockierungsinformationen werden zurückgesetzt.

Überprüfung der API-Benutzer und -Geheimnisse: Die Kopfzeilen der Anfrage werden auf gültige API-Benutzer und -Geheimnisse überprüft.
Wenn die Anmeldedaten korrekt sind, wird der Zähler für gültige Versuche erhöht.
Wenn die Anmeldedaten falsch sind, wird der Zähler für ungültige Versuche erhöht.
Wenn die Anzahl ungültiger Versuche einen bestimmten Schwellenwert überschreitet (z.B. 50), wird die IP-Adresse blockiert.

Versuchsverfolgung: Die Anzahl der erfolgreichen und fehlgeschlagenen Anmeldeversuche wird verfolgt, um die Blockierungslogik zu unterstützen.

Rückgabewert

Erfolgreiche Berechtigung: Wenn die Berechtigung erfolgreich ist, gibt die Funktion true zurück, wodurch die Haupt-Callback-Funktion hnp_api_firewall_callback aufgerufen wird.
Fehlgeschlagene Berechtigung: Wenn die Berechtigung fehlschlägt, wird ein Fehler zurückgegeben und die Haupt-Callback-Funktion wird nicht ausgeführt.

Haupt-Callback-Funktion

Die Haupt-Callback-Funktion hnp_api_firewall_callback wird aufgerufen, wenn die Berechtigung erfolgreich ist und die Route erreicht wird. Sie gibt eine JSON-Antwort mit dem Dateninhalt zurück, der in diesem Fall ein einfaches Beispiel mit {"testdata": "test"} ist.

// Register the custom REST route
add_action('rest_api_init', function () {
    register_rest_route('hnp_api_firewall/v1', '/api', array(
        'methods' => 'POST',
        'callback' => 'hnp_api_firewall_callback',
        'permission_callback' => 'hnp_api_firewall_combined_permissions',
    ));
});

// Combined function to handle permissions and blocking logic
function hnp_api_firewall_combined_permissions(WP_REST_Request $request) {
    $ip_address = sanitize_text_field($_SERVER['REMOTE_ADDR']);
    $blocked_ips = get_option('hnp_blocked_ips', array());

    // Check if IP is blocked
    if (isset($blocked_ips[$ip_address])) {
        $block_info = $blocked_ips[$ip_address];
        $block_time = $block_info['block_time'];
        $block_duration = $block_info['block_duration'];
        $current_time = current_time('timestamp');

        // If current time is less than block time + block duration, deny access
        if ($current_time < ($block_time + $block_duration)) {
            return new WP_Error('blocked_ip', 'Your IP is temporarily blocked due to too many attempts.', array('status' => 403));
        } else {
            // Unblock IP and reset attempts after block duration
            unset($blocked_ips[$ip_address]);
            update_option('hnp_blocked_ips', $blocked_ips);
        }
    }

    // Check API user and secret
    $api_user = $request->get_header('APIUser');
    $api_secret = $request->get_header('APISecret');
    $valid_api_user = '4GI53seaRLu!FK9XEiAk323U6M!f2bT7Sda28ZqsaegQCn0!Y121Y1L';
    $valid_api_secret = '091572EddV!YcTKGR3Q13a!CM6TN!UWbPqFRdwa1XpP!1g8o32aaJD4';

    // Tracking attempts
    $attempts = get_option('hnp_attempts', array());

    if (!isset($attempts[$ip_address])) {
        $attempts[$ip_address] = array(
            'valid_count' => 0,
            'invalid_count' => 0,
            'invalid_license_count' => 0,
            'first_attempt_time' => current_time('timestamp')
        );
    }

    $permission_granted = null !== $api_user && $api_user === $valid_api_user && null !== $api_secret && $api_secret === $valid_api_secret;

    if ($permission_granted) {
        $attempts[$ip_address]['valid_count']++;
    } else {
        $attempts[$ip_address]['invalid_count']++;

        // Block IP if invalid attempts exceed threshold (e.g., 50)
        if ($attempts[$ip_address]['invalid_count'] >= 50) {
            $blocked_ips[$ip_address] = array('block_time' => current_time('timestamp'), 'block_duration' => 12 * HOUR_IN_SECONDS);
            update_option('hnp_blocked_ips', $blocked_ips);
            return new WP_Error('blocked_ip', 'Your IP is temporarily blocked due to too many invalid attempts for API Secret/Username.', array('status' => 403));
        }

        update_option('hnp_attempts', $attempts);
        return new WP_Error('invalid_credentials', 'Invalid API Secret key or password.', array('status' => 403));
    }

    // Reset invalid attempts on successful authentication
    if (isset($attempts[$ip_address])) {
        unset($attempts[$ip_address]['invalid_count']);
        update_option('hnp_attempts', $attempts);
    }

    return true;
}

function hnp_api_firewall_callback() {
    return new WP_REST_Response(array(
        'testdata' => 'test'
    ), 200);
}

cUrl Anfrage zum Testen:

curl -X POST https://yourdomain.com/wp-json/hnp_api_firewall/v1/api \
     -H "APIUser: 4GI53seaRLu!FK9XEiAk323U6M!f2bT7Sda28ZqsaegQCn0!Y121Y1L" \
     -H "APISecret: 091572EddV!YcTKGR3Q13a!CM6TN!UWbPqFRdwa1XpP!1g8o32aaJD4"

PHP Anfrage zum Testen:

<?php

function call_hnp_api_firewall() {
    $url = 'https://yourdomain.com/wp-json/hnp_api_firewall/v1/api';
    
    $args = array(
        'headers' => array(
            'APIUser' => '4GI53seaRLu!FK9XEiAk323U6M!f2bT7Sda28ZqsaegQCn0!Y121Y1L',
            'APISecret' => '091572EddV!YcTKGR3Q13a!CM6TN!UWbPqFRdwa1XpP!1g8o32aaJD4'
        ),
        'body' => array(
            // Any additional data you want to send in the body
        )
    );

    $response = wp_remote_post($url, $args);

    if (is_wp_error($response)) {
        $error_message = $response->get_error_message();
        echo "Something went wrong: $error_message";
    } else {
        $response_body = wp_remote_retrieve_body($response);
        echo 'Response:<br>';
        echo '<pre>';
        print_r(json_decode($response_body, true));
        echo '</pre>';
    }
}

// Call the function
call_hnp_api_firewall();

?>

C# Anfrage zum Testen:

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

class Program
{
    private static async Task CallHnpApiFirewallAsync()
    {
        var url = "https://yourdomain.com/wp-json/hnp_api_firewall/v1/api";
        
        using (var client = new HttpClient())
        {
            // Set the APIUser and APISecret headers
            client.DefaultRequestHeaders.Add("APIUser", "4GI53seaRLu!FK9XEiAk323U6M!f2bT7Sda28ZqsaegQCn0!Y121Y1L");
            client.DefaultRequestHeaders.Add("APISecret", "091572EddV!YcTKGR3Q13a!CM6TN!UWbPqFRdwa1XpP!1g8o32aaJD4");

            // Optionally set the content of the request (if needed)
            var content = new StringContent("", System.Text.Encoding.UTF8, "application/json");

            try
            {
                var response = await client.PostAsync(url, content);

                if (response.IsSuccessStatusCode)
                {
                    var responseBody = await response.Content.ReadAsStringAsync();
                    Console.WriteLine("Response:");
                    Console.WriteLine(responseBody);
                }
                else
                {
                    Console.WriteLine($"Error: {response.StatusCode}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Exception: {ex.Message}");
            }
        }
    }

    static void Main(string[] args)
    {
        Task.Run(() => CallHnpApiFirewallAsync()).GetAwaiter().GetResult();
    }
}

Sicherheit:

Anzahl der möglichen Kombinationen bei BrutForceAttacken

Einzelne Schlüssel:

Für einen einzelnen Schlüssel mit 50 Zeichen und 94 möglichen Zeichen pro Position ergibt sich:
945094 hoch50
Zwei Schlüssel kombiniert

Da beide Schlüssel unabhängig voneinander betrachtet werden, multiplizieren wir die Anzahl der möglichen Kombinationen beider Schlüssel:

(94 hoch50)×(94 hoch50)(94 hoch50)×(94 hoch50)

Dies entspricht:
9410094 hoch100

Zeit für einen Brute-Force-Angriff

Angenommen, ein Computer kann 1 Milliarde (1.000.000.000) Kombinationen pro Sekunde testen:

Anzahl der Kombinationen:
Die Anzahl der Kombinationen für einen Schlüssel: 945094 hoch50 (eine extrem große Zahl)
Die Anzahl der Kombinationen für beide Schlüssel: 9410094 hoch100 (noch viel größer)

Zeit für Brute-Force:
Selbst wenn ein Computer 1 Milliarde Kombinationen pro Sekunde testen könnte, würde das Testen aller Kombinationen von zwei Schlüsseln extrem lange dauern.
Zum Vergleich:
Eine Milliarde Sekunden sind etwa 31,7 Jahre.

Die Anzahl der Kombinationen für 9410094 hoch100 ist so groß, dass selbst mit extrem schneller Hardware Billionen von Jahren benötigt würden, um alle Kombinationen zu testen.

Durch die Rate Limitierung der Firewall wird die Zeit auf Milliarden von Jahren erhöht, zudem sind DDOS oder ähnliche Hacking-Angriffe nicht möglich. Die Schnittstelle wird somit zusätzlich geschützt.

Der Beitrag WordPress Rest API Schnittstelle mit Firewall erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Was der HNP Win Data Handler macht

Der HNP Win Data Handler ist ein WordPress-Plugin kombiniert mit einer C#-Anwendung, die zusammenarbeiten, um Daten sicher zu verwalten und auszutauschen. Das WordPress-Plugin definiert spezifische REST-API-Endpunkte, die es einer C#-Anwendung ermöglichen, Daten zu lesen (GET) und zu schreiben (POST). Diese Daten können für eine Vielzahl von Anwendungen nützlich sein, beispielsweise für das Abrufen und Aktualisieren von Konfigurationseinstellungen, Nutzerdaten oder anderen dynamischen Inhalten, die auf der WordPress-Seite gepflegt werden.

Download Exe & WordPress Plugin (sofort kostenlos nutzbar):
[sdm_download id=”8231″ fancy=”0″]
Shortcode in WordPress für Anzeige der Daten: [hnp_win_data_display]

Github:
https://github.com/HNP-Christopher-Rohde/Hnp-win-data-handler/tree/main

C# Source-Code für die Win EXE / Anwendung:
Die C#-Komponente handhabt die Benutzereingaben und interagiert direkt mit der REST-API. Sie bietet Funktionen zum Ändern der Domain-URL, zum Laden von Daten aus WordPress und zum Speichern von Änderungen an den Daten. Diese Flexibilität macht es möglich, die Datenverwaltung von jeder C#-basierten Benutzeroberfläche aus zu steuern.

// HNP Win Data Handler v.1.0 EXE
// Author: HNP C.R.
// Author URI: https://homepage-nach-preis.de/
// Licence: Creative Commons Non-Commercial 

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;

class hnp_win_data_Main
{
    private static readonly HttpClient client = new HttpClient();
    private static string domainFilePath = "hnp_win_data_domain.txt";
    private static string? domainUrl = null;

    private const string SecretKey = "9418BB768671A389";

    static async Task Main(string[] args)
    {
        client.DefaultRequestHeaders.Add("X-Secret-Key", SecretKey);

        await LoadDomain();
        while (true)
        {
            Console.WriteLine("\nMenu:");
            Console.WriteLine("1. Change Domain");
            Console.WriteLine("2. Load Data from WordPress");
            Console.WriteLine("3. Change and Save Data");
            Console.Write("Select an option: ");

            string? option = Console.ReadLine();
            switch (option)
            {
                case "1":
                    ChangeDomain();
                    break;
                case "2":
                    await LoadDataFromWordPress();
                    break;
                case "3":
                    await ChangeAndSaveData();
                    break;
                default:
                    Console.WriteLine("Invalid option.");
                    break;
            }
        }
    }

    static async Task LoadDomain()
    {
        if (File.Exists(domainFilePath))
        {
            domainUrl = await File.ReadAllTextAsync(domainFilePath) ?? string.Empty;
            Console.WriteLine($"Loaded domain: {domainUrl}");
        }
        else
        {
            Console.Write("Enter domain URL: ");
            domainUrl = Console.ReadLine();
            if (!string.IsNullOrWhiteSpace(domainUrl))
            {
                await File.WriteAllTextAsync(domainFilePath, domainUrl);
            }
        }
    }

    static void ChangeDomain()
    {
        Console.Write("Enter new domain URL: ");
        string? newDomainUrl = Console.ReadLine();
        if (!string.IsNullOrWhiteSpace(newDomainUrl))
        {
            domainUrl = newDomainUrl;
            File.WriteAllText(domainFilePath, domainUrl);
            Console.WriteLine("Domain updated successfully.");
        }
        else
        {
            Console.WriteLine("Invalid domain URL provided.");
        }
    }

    static async Task LoadDataFromWordPress()
    {
        if (!string.IsNullOrWhiteSpace(domainUrl))
        {
            try
            {
                HttpResponseMessage response = await client.GetAsync(domainUrl + "/wp-json/hnp-win-data/v1/data");
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                string decodedData = JsonConvert.DeserializeObject<string>(responseBody) ?? "Default or empty data";
                Console.WriteLine("Data loaded: " + decodedData);
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine("\nException Caught!");
                Console.WriteLine("Message :{0} ", e.Message);
            }
        }
        else
        {
            Console.WriteLine("Domain URL is not set. Please set the domain URL first.");
        }
    }

    static async Task ChangeAndSaveData()
    {
        Console.Write("Enter new data value: ");
        string? newData = Console.ReadLine();
        if (!string.IsNullOrWhiteSpace(newData) && !string.IsNullOrWhiteSpace(domainUrl))
        {
            var content = new StringContent($"\"{newData}\"", System.Text.Encoding.UTF8, "application/json");
            try
            {
                HttpResponseMessage response = await client.PostAsync(domainUrl + "/wp-json/hnp-win-data/v1/data", content);
                response.EnsureSuccessStatusCode();
                Console.WriteLine("Data saved successfully.");
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine("\nException Caught!");
                Console.WriteLine("Message :{0} ", e.Message);
            }
        }
        else
        {
            Console.WriteLine("Invalid data value or domain URL is not set.");
        }
    }
}

PHP Source Code für das WordPress Plugin:
Das Plugin registriert zwei REST-API-Endpunkte: einen für GET-Anfragen, um Daten abzurufen, und einen für POST-Anfragen, um Daten zu aktualisieren. Jede Anfrage wird über eine Funktion verarbeitet, die den geheimen Schlüssel überprüft, um sicherzustellen, dass nur berechtigte Anfragen bearbeitet werden.

<?php

 /*
  Plugin Name: HNP Win Data Handler
  Description: Handles data via custom REST API for an external C# application with security enhancements.
  Version: 1.0
  Author: HNP C.R.
  Author URI: https://homepage-nach-preis.de/
  License: GPLv3
  License URI: https://www.gnu.org/licenses/gpl-3.0.html
  Shortcode: hnp_win_data_display
*/

define('HNP_WIN_DATA_SECRET_KEY', '9418BB768671A389');  // Set your secret key here

// Register REST API routes
add_action('rest_api_init', function () {
    register_rest_route('hnp-win-data/v1', '/data', array(
        'methods' => 'GET',
        'callback' => 'hnp_win_data_get_data',
        'permission_callback' => 'hnp_win_data_check_secret_key'
    ));
    register_rest_route('hnp-win-data/v1', '/data', array(
        'methods' => 'POST',
        'callback' => 'hnp_win_data_set_data',
        'permission_callback' => 'hnp_win_data_check_secret_key'
    ));
});

// Function to handle GET request
function hnp_win_data_get_data(WP_REST_Request $request) {
    $value = get_option('hnp_win_data_value', 'No data set.');
    return new WP_REST_Response($value, 200);
}

// Function to handle POST request
function hnp_win_data_set_data(WP_REST_Request $request) {
    $data = $request->get_body();
    $clean_data = sanitize_text_field($data);
    update_option('hnp_win_data_value', $clean_data);
    return new WP_REST_Response('Data updated successfully.', 200);
}

// Permission check to validate secret key
function hnp_win_data_check_secret_key($request) {
    $headers = $request->get_headers();
    $provided_secret = $headers['x_secret_key'][0] ?? '';
    return $provided_secret === HNP_WIN_DATA_SECRET_KEY;
}

// Shortcode to display the data in the frontend
add_shortcode('hnp_win_data_display', 'hnp_win_data_display_shortcode');
function hnp_win_data_display_shortcode() {
    $value = get_option('hnp_win_data_value', 'No data set.');
    return esc_html($value);
}

Der HNP Win Data Handler ist ein Beispiel für die erfolgreiche Integration von Web- und Desktop-Technologien zur Datensynchronisation. Die Kombination aus einem WordPress-Plugin und einer C#-Anwendung bietet eine sichere und flexible Lösung für das Datenmanagement, die in vielen Geschäftsbereichen und Anwendungen nützlich sein kann. Mit seinem modularen Aufbau und der hohen Sicherheit stellt dieses System eine wertvolle Ressource für Entwickler dar, die in gemischten Technologieumgebungen arbeiten.

Der Beitrag HNP Win Data Handler – Datenaustausch zwischen WordPress & Windows erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

In der Welt des Webdesigns und der Content-Verwaltungssysteme ist Flexibilität der Schlüssel. WordPress, das beliebte CMS, bietet bereits eine Vielzahl von Funktionen, aber was, wenn Sie noch weiter gehen möchten? Was ist, wenn Sie Ihre Inhalte noch individueller gestalten möchten? Hier kommt das HNP WIN SHORTCODE Tool ins Spiel – ein innovatives WordPress-Plugin in Kombination mit einer leistungsstarken Windows x64-Software, die Ihnen die unbegrenzte Erstellung und Anpassung von Shortcodes ermöglicht.

Was ist das HNP WIN SHORTCODE Tool?

Das HNP WIN SHORTCODE Tool besteht aus zwei Hauptkomponenten: einem WordPress-Plugin und einer Windows x64-Software. Zusammen ermöglichen sie die einfache Erstellung und Verwaltung von Shortcodes mit anpassbaren Inhalten direkt von Ihrem Desktop aus.

Wie funktioniert es?

Das WordPress-Plugin integriert sich nahtlos in Ihre WordPress-Installation. Nach der Installation und Aktivierung stehen Ihnen sofort alle Funktionen zur Verfügung. Sie können die Anzahl der Shortcodes festlegen und die Daten bearbeiten, alles direkt über das Backend von WordPress.

Die Windows-Software bietet eine benutzerfreundliche Oberfläche, mit der Sie die Shortcodes und deren Inhalte laden und ändern können. Dank der Integration mit der WordPress-Rest-API können Sie die Änderungen direkt auf Ihrer Website veröffentlichen.

Funktionen des WordPress-Plugins:

• Einfache Einrichtung: Installieren und aktivieren Sie das Plugin – der Rest ist optional, da das Plugin bereits vorkonfiguriert ist.
• Backend-Verwaltung: Eine eigene Backend-Seite im Admin-Dashboard von WordPress ermöglicht die Verwaltung der Shortcodes und ihrer Inhalte.
• Anpassung: Passen Sie die Anzahl der Shortcodes an und definieren Sie die Daten, die ausgelesen und geändert werden sollen.
• Sprachunabhängig: Das Plugin ist derzeit nur in Englisch verfügbar, aber da Sie die Inhalte der Shortcodes selbst bestimmen können, ist die Sprache irrelevant.
• Performance und Sicherheit: Das Plugin nutzt pures JavaScript und ist mit PHP 7.X und PHP 8.X kompatibel. Die REST-API ist durch einen Secret Key geschützt.

Funktionen der Windows-Software:

• Einfache Nutzung: Starten Sie die Anwendung auf einem Windows-64-Bit-System und geben Sie Ihre Domain-Adresse ein – mehr ist nicht nötig.
• Vielseitigkeit: Die Anwendung funktioniert auf Servern, Laptops und herkömmlichen Computern.
• Anpassungsmöglichkeiten: Ändern Sie den Secret Key, die Anzahl der Shortcodes und die Domain-Adresse nach Bedarf.
• Speicherungsfunktion: Die Anwendung merkt sich die letzten Einstellungen für einen bequemen Autostart.
• Performance und Sicherheit: Nutzt keine externen Bibliotheken außer denen von Python, Netcore und GTK. Die Datenübertragung zur WordPress-Website erfolgt über die REST-API mit einem Secret Key.

Mehr Informationen und Download:
https://shop.homepage-nach-preis.de/produkt/hnp-unlimiterte-shortcodes-schnitstelle-wordpress-windows-x64/

Der Beitrag HNP WIN SHORTCODE Tool: Eine Revolution für WordPress erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Das HNP System Monitor Tool nutzt eine gesicherte REST API, um die aktuelle Systemauslastung des Windows-Geräts zu erfassen und diese Daten an Ihre WordPress-Webseite zu übertragen. Dort können Sie die Daten in einer visuell strukturierten Form betrachten und analysieren. Das Beste daran? Die Einrichtung ist denkbar einfach.
WordPress-Plugin: Starten und Loslegen

Das mitgelieferte WordPress-Plugin ist vorkonfiguriert, sodass Sie es lediglich installieren und aktivieren müssen. Es erzeugt eine Backend-Seite in Ihrem WordPress-Admin-Dashboard, auf der Sie die Server- oder Computerleistung in Echtzeit verfolgen können. Die Daten werden ohne Neuladen der Seite aktualisiert, dank AJAX-Requests. Zudem bietet das Plugin visuelle Feedbacks durch farbige Pfeile und eine grafische Anzeige der letzten 100 Datenpunkte. Mit den integrierten Shortcodes können Sie die Daten auch im Frontend Ihrer Webseite anzeigen lassen.
Exe Win Anwendung: Einfach und Effizient

Die begleitende Windows-64-Bit-Anwendung ist ebenfalls vorkonfiguriert. Nach dem Start der Anwendung und der Eingabe Ihrer Domain-Adresse übernimmt das System automatisch die Datenerfassung und -übertragung. Sie können den Secretkey, die Intervallzeit und andere Einstellungen direkt in der Anwendung ändern. Praktisch ist auch die Speicherungsfunktion, die die letzten Einstellungen für einen Autostart speichert.
Sicherheit und Performance

Sowohl das WordPress-Plugin als auch die Windows-Anwendung setzen auf hohe Sicherheitsstandards. Mit Nonce-Abfragen, gesicherten AJAX-Verbindungen und Schutz vor XSS-Angriffen sind Ihre Daten stets sicher. Zudem sind beide Systeme performance-optimiert, ohne externe Bibliotheken oder Treiber zu benötigen.
Flexibilität und Erweiterbarkeit

Das HNP System Monitor Tool bietet Ihnen die Freiheit, die Intervallzeit zum Datenaustausch nach Ihren Bedürfnissen anzupassen. Ob alle 2 Sekunden oder einmal täglich – Sie haben die Wahl. Darüber hinaus sind die Sourcefiles sowohl für das WordPress-Plugin als auch für die Windows-Anwendung im Lieferumfang enthalten. Dies ermöglicht erfahreneren Nutzern, das Tool nach Belieben anzupassen und zu erweitern.
Fazit

Das HNP System Monitor Tool ist ein modernes und benutzerfreundliches System zur Erfassung und Visualisierung von Systemdaten. Mit seiner einfachen Einrichtung, hohen Sicherheitsstandards und Flexibilität ist es eine ideale Lösung für jeden, der die Leistung seines Windows-Computers oder Servers im Auge behalten und diese Daten nahtlos in seine WordPress-Webseite integrieren möchte.

Beim Kauf erhalten Sie ein fertiges Run & Go WordPress-Plugin, eine Windows-64-Bit-Anwendung, sowie alle erforderlichen Sourcefiles für Anpassungen und Erweiterungen. Nutzen Sie die Gelegenheit und bringen Sie Ihre Systemüberwachung auf das nächste Level!

 Mehr Informationen:

https://shop.homepage-nach-preis.de/produkt/hnp-system-monitor-for-wordpress-windows-x64/

Der Beitrag HNP System Monitor Tool: Die Brücke zwischen Windows und WordPress erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Code-Beschreibung:

Shortcodes: Das Plugin fügt zwei Shortcodes hinzu: hnp_template_switcher und hnp_template_switcher_buttons.

hnp_template_switcher: Dieser Shortcode rendert den Bereich, in dem das ausgewählte Template dynamisch geladen wird. Es verwendet eine PHP-Include-Anweisung, um die entsprechende Template-Datei zu laden.

hnp_template_switcher_buttons: Dieser Shortcode rendert die Schaltflächen, mit denen Benutzer zwischen den verschiedenen Templates wählen können. Es gibt zwei Schaltflächen, um Template 1 und Template 2 zu laden.

JavaScript: Das Plugin verwendet JavaScript, um auf Benutzerinteraktionen zu reagieren und die Templates dynamisch zu laden. Es bindet Klickereignisse an die Schaltflächen, um die entsprechenden Templates zu laden. Dazu wird eine XMLHttpRequest verwendet, um die Template-Dateien abzurufen und sie dann in den Container zu rendern.

Vorteile und Nutzen:

Benutzerfreundlichkeit: Das Plugin macht es einfach, zwischen verschiedenen Vorlagen zu wechseln, ohne dass Benutzer den Code bearbeiten müssen. Durch die Verwendung von Shortcodes können Benutzer die Schaltflächen und den Template-Bereich einfach in ihre Seiten und Beiträge einfügen.

Flexibilität: Benutzer können verschiedene Templates erstellen und sie je nach Bedarf anpassen. Dies ermöglicht es, verschiedene Layouts und Designs für verschiedene Zwecke zu verwenden.

Zeitersparnis: Durch die Verwendung des Plugins können Benutzer Zeit sparen, da sie nicht jedes Mal den Code ändern müssen, wenn sie ein anderes Template verwenden möchten. Stattdessen können sie einfach die entsprechende Schaltfläche anklicken.

Umfang:

Das Plugin umfasst zwei Hauptkomponenten: die Shortcodes für den Template-Switcher und die zugehörige JavaScript-Funktionalität. Die Shortcodes sind einfach zu verwenden und erfordern nur minimale Konfiguration, während das JavaScript für die dynamische Laden der Templates sorgt.

Lizenz:

Das “HNP Dyn Template” Plugin wird unter der GNU General Public License (GPLv3) vertrieben, was bedeutet, dass es frei verwendet, modifiziert und weitergegeben werden kann, solange die Lizenzbedingungen eingehalten werden.

Download:
WordPress Plugin mit Ajax: [sdm_download id=”8168″ fancy=”0″]
WordPress Plugin ohne Ajax: [sdm_download id=”8171″ fancy=”0″]

WordPress Plugin Code ohne Ajax (schnellere Ladezeiten):

<?php
/*
* Plugin Name: HNP Dyn Template
* Plugin URI: https://homepage-nach-preis.de/
* Description: Erstellt 2 Button welche bei Betätigung die Template-Datei auswechseln. Shortcodes: hnp_template_switcher_buttons und hnp_template_switcher
* Version: 1.1
* Author: HNP
* Author URI: https://homepage-nach-preis.de/
* License: GPLv3
*/

// Shortcode für den Template-Switcher hinzufügen
add_shortcode('hnp_template_switcher', 'hnp_custom_template_switcher_shortcode');

// Funktion zum Rendern des Shortcodes
function hnp_custom_template_switcher_shortcode() {
    ob_start();
    ?>
    <div id="hnp-template-container">
        <!-- Hier wird das Template dynamisch geladen -->
        <?php include_once(plugin_dir_path(__FILE__) . '/templates/hnp_template_1.php'); ?>
    </div>
    <?php
    return ob_get_clean();
}

// Shortcode für die Schaltflächen zum Wechseln der Templates hinzufügen
add_shortcode('hnp_template_switcher_buttons', 'hnp_custom_template_switcher_buttons_shortcode');

// Funktion zum Rendern des Shortcodes für die Schaltflächen
function hnp_custom_template_switcher_buttons_shortcode() {
    ob_start();
    ?>
    <button id="hnp-template1-btn">Template 1 laden</button>
    <button id="hnp-template2-btn">Template 2 laden</button>
    <?php
    return ob_get_clean();
}

// JavaScript zum Schalten der Templates hinzufügen
add_action('wp_footer', 'hnp_custom_template_switcher_js');

function hnp_custom_template_switcher_js() {
    ?>
    <script>
    document.addEventListener('DOMContentLoaded', function() {
        document.getElementById('hnp-template1-btn').addEventListener('click', function() {
            loadTemplate('hnp_template_1.php');
        });
        document.getElementById('hnp-template2-btn').addEventListener('click', function() {
            loadTemplate('hnp_template_2.php');
        });
    });

	function loadTemplate(templateUrl) {
		var xhr = new XMLHttpRequest();
		xhr.open('GET', '<?php echo plugins_url("templates/", __FILE__); ?>' + templateUrl, true);
		xhr.onreadystatechange = function() {
			if (xhr.readyState === 4 && xhr.status === 200) {
				document.getElementById('hnp-template-container').innerHTML = xhr.responseText;
			}
		};
		xhr.send();
	}

    </script>
    <?php
}

Template 1 Datei:

<?php
/*
Template Name: Template 1
*/
?>

<div class="hnp-template-content">
    <h2>Template 1</h2>
    <p>Dies ist der Inhalt von Template 1.</p>
</div>

Template 2 Datei:

<?php
/*
Template Name: Template 2
*/
?>

<div class="hnp-template-content">
    <h2>Template 2</h2>
    <p>Dies ist der Inhalt von Template 2.</p>
</div>

WordPress Plugin Code mit Ajax:

<?php
/*
* Plugin Name: HNP Dyn Template
* Plugin URI: https://homepage-nach-preis.de/
* Description: Erstellt 2 Button welche bei Betätigung die Template-Datei auswechseln. Shortcodes: hnp_template_switcher_buttons und hnp_template_switcher
* Version: 1.1
* Author: HNP
* Author URI: https://homepage-nach-preis.de/
* License: HNP-Dyn-Template
*/

// Shortcode für den Template-Switcher hinzufügen
add_shortcode('hnp_template_switcher', 'hnp_custom_template_switcher_shortcode');

// Funktion zum Rendern des Shortcodes
function hnp_custom_template_switcher_shortcode() {
    ob_start();
    ?>
    <div id="hnp-template-container">
        <!-- Hier wird das Template dynamisch geladen -->
        <?php include_once(plugin_dir_path(__FILE__) . '/templates/hnp_template_1.php'); ?>
    </div>
    <?php
    return ob_get_clean();
}

// Shortcode für die Schaltflächen zum Wechseln der Templates hinzufügen
add_shortcode('hnp_template_switcher_buttons', 'hnp_custom_template_switcher_buttons_shortcode');

// Funktion zum Rendern des Shortcodes für die Schaltflächen
function hnp_custom_template_switcher_buttons_shortcode() {
    ob_start();
    ?>
    <button id="hnp-template1-btn">Template 1 laden</button>
    <button id="hnp-template2-btn">Template 2 laden</button>
    <?php
    return ob_get_clean();
}

// JavaScript zum Schalten der Templates hinzufügen
add_action('wp_footer', 'hnp_custom_template_switcher_js');

function hnp_custom_template_switcher_js() {
    wp_enqueue_script('hnp-custom-template-switcher', plugin_dir_url(__FILE__) . 'hnp_dyn_template.js', array('jquery'), null, true);

    wp_localize_script('hnp-custom-template-switcher', 'hnpTemplateSwitcher', array(
        'ajaxurl' => admin_url('admin-ajax.php')
    ));
}

// Ajax
add_action('wp_ajax_load_template', 'hnp_load_template_ajax');
add_action('wp_ajax_nopriv_load_template', 'hnp_load_template_ajax');

function hnp_load_template_ajax() {
    $template = isset($_GET['template']) ? $_GET['template'] : '';

    if ($template) {
        // Hier können Sie die Template-Datei laden und den Inhalt zurückgeben
        include(plugin_dir_path(__FILE__) . '/templates/' . $template);
    }

    wp_die();
}

Javascript:

document.addEventListener('DOMContentLoaded', function() {
    document.getElementById('hnp-template1-btn').addEventListener('click', function() {
        loadTemplate('hnp_template_1.php');
    });
    document.getElementById('hnp-template2-btn').addEventListener('click', function() {
        loadTemplate('hnp_template_2.php');
    });
});

function loadTemplate(templateUrl) {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', hnpTemplateSwitcher.ajaxurl + '?action=load_template&template=' + templateUrl, true);
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4 && xhr.status === 200) {
            document.getElementById('hnp-template-container').innerHTML = xhr.responseText;
        }
    };
    xhr.send();
}

Template Dateien hierbei identisch.

Der Beitrag Dynamische Templates in WordPress erzeugen & einbinden erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Die grundlegende Arbeitsweise von AJAX besteht darin, dass der Browser mithilfe von JavaScript eine HTTP-Anfrage an den Server sendet. Der Server verarbeitet dann die Anfrage und sendet eine Antwort zurück, die vom JavaScript-Code auf der Client-Seite verarbeitet wird.

In der Regel werden AJAX-Anfragen verwendet, um Daten im Hintergrund zu laden, Benutzeraktionen zu verarbeiten oder mit einem Server zu kommunizieren, ohne dass die Seite neu geladen werden muss. Dies kann beispielsweise bei der Validierung von Formularen, dem Laden von zusätzlichen Inhalten oder der Aktualisierung von Benutzerdaten nützlich sein.

Um AJAX in einer Webseite zu implementieren, wird normalerweise JavaScript verwendet, um die Anfrage zu senden, und auf der Serverseite wird die Anfrage mit einer Programmiersprache wie PHP oder Python verarbeitet.

In WordPress wird AJAX häufig verwendet, um dynamische Inhalte in Themes und Plugins zu laden, ohne die Seite neu zu laden. WordPress bietet spezielle Funktionen und Hooks für die Verarbeitung von AJAX-Anfragen, was die Implementierung erleichtert. Hierzu ein praktisches Beispiel:
WordPress:
Javascript:

document.addEventListener("DOMContentLoaded", function() {
    var hnpAjaxButton = document.getElementById("hnp_ajax_button");
    
    hnpAjaxButton.addEventListener("click", function() {
        var xhr = new XMLHttpRequest();
        xhr.open("POST", ajax_object.ajax_url, true);
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
        xhr.onreadystatechange = function() {
            if (xhr.readyState === 4 && xhr.status === 200) {
                alert("Server sagt: " + xhr.responseText);
            }
        };
        xhr.send("action=hnp_ajax_funktion");
    });
});

PHP

add_action('wp_enqueue_scripts', 'hnp_ajax_scripts');
function hnp_ajax_scripts() {
    wp_enqueue_script('hnp-ajax-script', get_stylesheet_directory_uri() . '/js/hnp-ajax-script.js', array(), '1.0', true);
    wp_localize_script('hnp-ajax-script', 'ajax_object', array('ajax_url' => admin_url('admin-ajax.php')));
}

add_action('wp_ajax_hnp_ajax_funktion', 'meine_ajax_callback');
add_action('wp_ajax_nopriv_hnp_ajax_funktion', 'meine_ajax_callback');
function meine_ajax_callback() {
    echo 'Hallo von AJAX!';
    die();
}

HTML:

<button id="hnp_ajax_button">Klick mich für eine Begrüßungsnachricht!</button>

ODER Universal:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX Beispiel</title>
</head>
<body>
    <button id="hnp_ajax_button">Klick mich für eine Begrüßungsnachricht!</button>

    <script>
        document.addEventListener("DOMContentLoaded", function() {
            var hnpAjaxButton = document.getElementById("hnp_ajax_button");
            
            hnpAjaxButton.addEventListener("click", function() {
                var xhr = new XMLHttpRequest();
                xhr.open("POST", "server.php", true); // Hier "server.php" durch die URL des Servers ersetzen, der die AJAX-Anfrage verarbeitet
                xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
                xhr.onreadystatechange = function() {
                    if (xhr.readyState === 4 && xhr.status === 200) {
                        alert("Server sagt: " + xhr.responseText);
                    }
                };
                xhr.send("action=hnp_ajax_funktion");
            });
        });
    </script>
</body>
</html>

Der Beitrag Ajax und WP-Ajax verstehen – Code Beispiel erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

HTML Code:

<div class="hnp_container" onmouseover="hnp_showImage2()" onmouseout="hnp_showImage1()">
  <img class="hnp_image" src="WWW.IHRE-WEBSEITE.DE/BILDDATEI-1.JPG" alt="Image 1">
  <img class="hnp_image hnp_image2" src="WWW.IHRE-WEBSEITE.DE/BILDDATEI-2.JPG&" alt="Image 2">
</div>

Javascript Code:

<script>
  function hnp_showImage2() {
    document.querySelector('.hnp_image').style.display = 'none';
    document.querySelector('.hnp_image2').style.display = 'block';
  }

  function hnp_showImage1() {
    document.querySelector('.hnp_image').style.display = 'block';
    document.querySelector('.hnp_image2').style.display = 'none';
  }
</script>

Css:

<style>
  .hnp_container {
    position: relative;
    width: 300px;
    height: 300px;
  }
  .hnp_image {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
  }
  .hnp_image2 {
    display: none;
  }
</style>

Der Beitrag Bild austauschen bei Maus Hover Funktion erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Folgende CSS-Variablen stehen zur Verfügung:

• hnp_primary-color
• hnp_secondary-color
• hnp_tertiary-color
• hnp_quaternary-color
• hnp_quinary-color
• hnp_font-size-small
• hnp_font-size-medium
• hnp_font-size-large
• hnp_font-weight-normal
• hnp_font-weight-bold
• hnp_font-weight-light
• hnp_font-family-primary
• hnp_font-family-secondary
• hnp_padding-small
• hnp_padding-big
• hnp_transparency-low
• hnp_transparency-high
• hnp_margin-small
• hnp_margin-big

Zusammenfassung der Funktionen:

• Erstellt eine Optionen-Seite im Plugin, um die VAR CSS-Werte festzulegen und zu speichern.
• Verwendet JavaScript (ohne jQuery), um die Variablen mit dem CSS zu verbinden.
• Nutzen Sie die CSS-Variablen für Container, Schriftarten oder andere Stilelemente in Ihrem Theme.

Mehr Information und Download:
HNP Variable CSS WordPress Plugin

Der Beitrag HNP Variable CSS WordPress Plugin erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Das HNP Temp Product WooCommerce Plugin erweitert WordPress-Websites, die WooCommerce verwenden, um temporäre Produkte zu verkaufen. Mit einem einfachen Shortcode können Sie einen “Warenkorb” -Button hinzufügen, der es Benutzern ermöglicht, individuelle temporäre Produkte direkt in den Warenkorb zu legen. Dieses temporäre Produkt wird automatisch erstellt, sobald der Button gedrückt wird, ohne dass Sie ein spezielles WooCommerce-Produkt erstellen müssen. Nach einer bestimmten Zeit kann das Produkt automatisch aus dem Warenkorb entfernt werden.

Zusammenfassung der Funktionen:

• Einfache Integration: Der Warenkorb-Button kann überall auf der Website platziert werden.
• Automatische Produkterstellung: Das Drücken des Buttons erstellt automatisch ein temporäres Produkt im Warenkorb.
• Benutzerfreundlichkeit: Benutzer werden automatisch zum Warenkorb weitergeleitet.
• Flexibilität: Das Plugin ermöglicht es Entwicklern, das Verhalten des Buttons durch Hinzufügen einer Post-ID anzupassen, um Daten von benutzerdefinierten Beitragstypen oder Blogbeiträgen zu nutzen.
• Sicherheit: Das Plugin enthält Sicherheitsoptimierungen gegen XSS-Angriffe und direkte Datei-Aufrufe.
• Performance: Verwendet direktes Javascript ohne jQuery und keine externen Bibliotheken, was zu einer guten Leistung führt. Kompatibel mit PHP 7.x und 8.x.

Mehr Informationen und Download:
Temporäre Produkte WooCommerce Plugin

Der Beitrag Temporäre Produkte WooCommerce Plugin erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.