Wordpress Code News Kategorie - Homepage-nach-Preis

WordPress Rest API Schnittstelle mit Firewall

Homepage-nach-Preis — Wed, 22 May 2024 12:41:18 +0000

Registrierung der benutzerdefinierten REST-Route

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.

HNP Win Data Handler – Datenaustausch zwischen WordPress & Windows

Homepage-nach-Preis — Sat, 27 Apr 2024 13:27:14 +0000

In einer Zeit, in der die Integration verschiedener Technologien zunehmend an Bedeutung gewinnt, bietet der “HNP Win Data Handler” eine effiziente Lösung für die sichere Datenübertragung zwischen einer WordPress-Website und einer externen C#-Anwendung. Dieses System stellt eine maßgeschneiderte REST API zur Verfügung, die speziell dafür entwickelt wurde, um von jeder C#-basierten Anwendung aus auf die Daten einer WordPress-Seite zuzugreifen.

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.

WooCommerce Warenkorb Leeren & Session Button

Homepage-nach-Preis — Mon, 15 Apr 2024 14:27:03 +0000

Das HNP Warenkorb Leeren Button Plugin für WooCommerce und WordPress erzeugt einen Button auf der Warenkorb-Seite, welcher bei Betätigung den kompletten Warenkorb leert und zudem die Session und Cookies resetet.

Download:
[sdm_download id=”8202″ fancy=”0″]

<?php
/**
Plugin Name: HNP Clear WooCommerce Cart & Session
Description: Ein Plugin zum Leeren des WooCommerce Warenkorbs und Löschen von Sessions und Cookies.
Version: 1.2
Author: HNP C.R.
Author URI: https://homepage-nach-preis.de/
License: GPLv3
License URI: https://www.gnu.org/licenses/gpl-3.0.html
 */

// Exit, wenn der Direktzugriff verhindert ist
if (!defined('ABSPATH')) {
    exit;
}

function hnp_cwc_enqueue_scripts() {
    if (is_cart() && get_option('hnp_cwc_enable', 'no') == 'yes' && get_option('hnp_cwc_hook_enable', 'no') == 'yes') {
        $nonce = wp_create_nonce('hnp_cwc_nonce');
        
        $script = "
            var ajaxurl = '" . admin_url('admin-ajax.php') . "';
            var nonce = '" . $nonce . "';
            
            document.addEventListener('DOMContentLoaded', function() {
                var clearCartButton = document.getElementById('clear-cart');
                
                clearCartButton.addEventListener('click', function() {
                    // Clear cart
                    var xhr = new XMLHttpRequest();
                    xhr.open('POST', ajaxurl, true);
                    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
                    xhr.setRequestHeader('X-WP-Nonce', nonce);
                    xhr.onload = function() {
                        if (this.status >= 200 && this.status < 400) {
                            console.log('Cart Cleared', this.responseText);
                            
                            // Clear sessions and cookies
                            var xhr2 = new XMLHttpRequest();
                            xhr2.open('POST', ajaxurl, true);
                            xhr2.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
                            xhr2.setRequestHeader('X-WP-Nonce', nonce);
                            xhr2.onload = function() {
                                if (this.status >= 200 && this.status < 400) {
                                    console.log('Sessions and Cookies Cleared', this.responseText);
                                    
                                    // Reload the page after clearing cart and sessions/cookies
                                    location.reload();
                                } else {
                                    console.error('Error clearing sessions and cookies', this);
                                }
                            };
                            xhr2.onerror = function() {
                                console.error('Error clearing sessions and cookies', this);
                            };
                            xhr2.send('action=hnp_clear_sessions_cookies&nonce=' + nonce);
                            
                        } else {
                            console.error('Error clearing cart', this);
                        }
                    };
                    xhr.onerror = function() {
                        console.error('Error clearing cart', this);
                    };
                    xhr.send('action=hnp_clear_cart_session&nonce=' + nonce);
                });
            });
        ";
        wp_add_inline_script('jquery', $script);
    }
}


add_action('wp_enqueue_scripts', 'hnp_cwc_enqueue_scripts');



// Register shortcode
function hnp_cwc_button_shortcode() {
    ob_start(); ?>
    <button id="clear-cart">Warenkorb leeren</button>
    <?php
    return ob_get_clean();
}
add_shortcode('hnp_cwc_button', 'hnp_cwc_button_shortcode');

// Hook to display the button on cart page
function hnp_cwc_display_button() {
    if (get_option('hnp_cwc_hook_enable', 'no') == 'yes') {
        echo do_shortcode('[hnp_cwc_button]');
    }
}
add_action('woocommerce_cart_actions', 'hnp_cwc_display_button');

// AJAX handler to clear cart
function hnp_cwc_clear_cart() {
    check_ajax_referer('hnp_cwc_nonce', 'nonce');

    try {
        WC()->cart->empty_cart();
        echo 'Cart Cleared';
    } catch (Exception $e) {
        echo 'Error clearing cart: ' . $e->getMessage();
    }
    die();
}

add_action('wp_ajax_hnp_clear_cart_session', 'hnp_cwc_clear_cart');
add_action('wp_ajax_nopriv_hnp_clear_cart_session', 'hnp_cwc_clear_cart');


// AJAX handler to clear sessions and cookies
function hnp_cwc_clear_sessions_cookies() {
    check_ajax_referer('hnp_cwc_nonce', 'nonce');

    try {
        // Reset WooCommerce session
        WC()->session->set_customer_session_cookie(false);
        WC()->session->set_session_cookie(false);
        WC()->session->reset_session();

        // Unset all cookies
        foreach ($_COOKIE as $cookie_key => $cookie_value) {
            unset($_COOKIE[$cookie_key]);
            setcookie($cookie_key, '', time() - 3600, '/', $_SERVER['HTTP_HOST']);
            setcookie($cookie_key, '', time() - 3600, '/', '.' . $_SERVER['HTTP_HOST']);
        }

        echo 'Sessions and Cookies Cleared';
    } catch (Exception $e) {
        echo 'Error clearing sessions and cookies: ' . $e->getMessage();
    }
    die();
}


add_action('wp_ajax_hnp_clear_sessions_cookies', 'hnp_cwc_clear_sessions_cookies');
add_action('wp_ajax_nopriv_hnp_clear_sessions_cookies', 'hnp_cwc_clear_sessions_cookies');


// Admin settings
function hnp_cwc_admin_menu() {
    add_menu_page(
        'HNP Clear WooCommerce Cart Settings', 
        'HNP Clear WooCommerce Cart',           
        'manage_options',                   
        'hnp_cwc_settings',                 
        'hnp_cwc_settings_page',            
		 plugin_dir_url(__FILE__) . 'img/hnp-favi.png'                               
    );
}
add_action('admin_menu', 'hnp_cwc_admin_menu');

function hnp_cwc_settings_page() {
	if (!current_user_can('manage_options')) {
        return;
    }
    if ($_SERVER['REQUEST_METHOD'] === 'POST' && check_admin_referer('hnp_cwc_nonce', 'hnp_cwc_nonce_field')) {
        if (isset($_POST['hnp_cwc_enable'])) {
            update_option('hnp_cwc_enable', $_POST['hnp_cwc_enable']);
        } else {
            update_option('hnp_cwc_enable', 'no');
        }

        if (isset($_POST['hnp_cwc_hook_enable'])) {
            update_option('hnp_cwc_hook_enable', $_POST['hnp_cwc_hook_enable']);
        } else {
            update_option('hnp_cwc_hook_enable', 'no');
        }
    }

    $enabled = get_option('hnp_cwc_enable', 'no');
    $hook_enabled = get_option('hnp_cwc_hook_enable', 'no');
    $nonce = wp_create_nonce('hnp_cwc_nonce');
    ?>
    <div class="wrap">
        <h2>HNP Clear WooCommerce Cart Settings</h2>
        <form method="post" action="">
            <?php wp_nonce_field('hnp_cwc_nonce', 'hnp_cwc_nonce_field'); ?>
            <table class="form-table">
                <tr>
                    <th scope="row">Allgemeine Funktion aktivieren</th>
                    <td>
                        <input type="checkbox" name="hnp_cwc_enable" value="yes" <?php checked('yes', $enabled); ?> />
                    </td>
                </tr>
                <tr>
                    <th scope="row">Hook für Warenkorb aktivieren</th>
                    <td>
                        <input type="checkbox" name="hnp_cwc_hook_enable" value="yes" <?php checked('yes', $hook_enabled); ?> />
                    </td>
                </tr>
				<tr>Shortcode um den Button manuell einzubinden: [hnp_cwc_button]</tr>
            </table>
            <?php submit_button(); ?>
        </form>
    </div>
    <?php
}

Der Beitrag WooCommerce Warenkorb Leeren & Session Button erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

HNP Empty Plugin – WordPress Demo Code

Homepage-nach-Preis — Wed, 10 Apr 2024 13:54:30 +0000

Das HNP Empty Plugin ist ein einfaches Demo-Plugin für WordPress, das entwickelt wurde, um grundlegende Funktionen eines Plugins zu demonstrieren. Es zeigt, wie man Styles und Skripte sowohl im Frontend als auch im Backend von WordPress einbindet. Außerdem bietet es eine Benutzeroberfläche zur Verwaltung von Plugin-Optionen über das WordPress-Dashboard. Der Plugin-Demo Code besitzt alle wichtigen Sicherheitsoptionen und Code-Qualitätsanforderungen, damit ein Plugin im offiziellen WordPress Verzeichnis aufgenommen wird. Zudem Funktionen, welche im Jahr 2024 auf dem neuesten Stand sind. Somit eine gute Grundlage für WordPress-Plugin-Entwickler. Geteste Kompatibilität: WordPress 6.5.2 und PHP 8.3. Das Plugin wird aber auch mit neueren und älteren PHP und WordPress Versionen kompatibel sein.

Features:

Frontend und Backend Styling: Das Plugin fügt sowohl dem Frontend als auch dem Backend von WordPress benutzerdefinierte CSS- und JavaScript-Dateien hinzu, um das Erscheinungsbild anzupassen.
Plugin-Optionen: Es bietet eine einfache Möglichkeit, Plugin-Optionen über das WordPress-Dashboard zu konfigurieren, einschließlich Textfelder, Zahlenfelder, Farbwähler, Dropdown-Listen und Checkboxen.
Shortcode: Das Plugin stellt einen Shortcode bereit, mit dem Benutzer die konfigurierten Optionen auf beliebigen Seiten oder Beiträgen anzeigen können.
Sicherheitsmaßnahmen: Das Plugin implementiert Sicherheitsmaßnahmen wie Nonce-Überprüfung, um unerwünschte Zugriffe auf die Plugin-Einstellungen zu verhindern.

Plugin-Download: [sdm_download id=”8187″ fancy=”0″]
Github: https://github.com/HNP-Christopher-Rohde/hnp_empty_wordpress_plugin
Quellcode:

Name Field: ' . esc_html($name) . '';
    echo 'Number Field: ' . esc_html($number) . '';
    echo 'Color Field: ' . esc_html($color) . '';
    echo 'Description Field: ' . esc_html($description) . '';
    echo 'Dropdown Field: ' . esc_html($dropdown) . '';
    echo 'Checkbox Field: ' . ($checkbox ? 'Enabled' : 'Disabled') . '';
}
add_shortcode('hnp_empty_plugin_echo_func', 'hnp_empty_plugin_echo_func');


// Function to add plugin options to the main menu
function hnp_empty_plugin_add_plugin_options_page() {
    // Check permission
    if (current_user_can('manage_options')) {
        add_menu_page(
            'HNP Empty Plugin Settings',
            'HNP Empty Plugin',
            'manage_options',
            'hnp-empty-plugin-settings',
            'hnp_empty_plugin_render_plugin_options_page',
            plugin_dir_url(__FILE__) . 'img/hnp-favi.png' 
        );
    }
}
add_action('admin_menu', 'hnp_empty_plugin_add_plugin_options_page');


// Function to render plugin options page
function hnp_empty_plugin_render_plugin_options_page() {
    ?>
    
        HNP Empty Plugin Settings
        
            
            
            
            
            
            
        
    
    
// Callback function for demo section
function hnp_empty_plugin_demo_section_callback() {
    echo 'This a Demo Plugin. Frontend-Shortcode: [hnp_empty_plugin_echo_func]';
}

// Callback function for name field
function hnp_empty_plugin_name_field_callback() {
    $value = get_option('hnp_empty_plugin_name_field', 'Name'); // Fallback value is 'Name'
    echo '';
}

// Callback functions for number fields
function hnp_empty_plugin_number_field_callback() {
    $value = get_option('hnp_empty_plugin_number_field', '12'); // Fallback value is '12'
    echo '';
}

// Callback function for Color Field
function hnp_empty_plugin_color_field_callback() {
    $value = get_option('hnp_empty_plugin_color_field', '#ff0000'); // Fallback value is red color
    echo '';
}

// Callback function for Description Field
function hnp_empty_plugin_description_field_callback() {
    $value = get_option('hnp_empty_plugin_description_field', 'Im a Desc Field'); // Fallback value is 'Im a Desc Field'
    echo '' . esc_html($value) . '';
}

// Callback function for dropdown field
function hnp_empty_plugin_dropdown_field_callback() {
    $value = get_option('hnp_empty_plugin_dropdown_field', 'option1'); // Fallback value is 'option1'
    ?>
    
    
    
        >
        Enable Checkbox
    
    
Der Beitrag HNP Empty Plugin – WordPress Demo Code erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

HNP OpenStreetMap kostenloses Plugin

Homepage-nach-Preis — Wed, 10 Apr 2024 10:19:20 +0000

Das “HNP OpenStreetMap Shortcode” Plugin ermöglicht es Benutzern, OpenStreetMap-Karten mit einem Pin direkt auf ihrer WordPress-Website einzubetten, indem sie einen Shortcode verwenden. Es bietet eine einfache Möglichkeit, einen Standort auf einer interaktiven Karte zu markieren.

Hier sind die Hauptmerkmale des Plugins:

Shortcode-Unterstützung: Benutzer können den bereitgestellten Shortcode verwenden, um eine Karte mit einem Pin an einem bestimmten Standort anzuzeigen.
Anpassbare Optionen: Das Plugin bietet verschiedene anpassbare Optionen, darunter die Möglichkeit, die Adresse des Pins, den Namen des Markers, den Zoomlevel der Karte, den Kartenstil sowie die Höhe und Breite der Karte anzupassen.
Integrierte Sicherheitsmaßnahmen: Das Plugin enthält Sicherheitsmaßnahmen wie Nonce-Überprüfung, um unautorisierte Zugriffe auf die Plugin-Optionen zu verhindern und die Datenintegrität zu gewährleisten.
Einfache Konfiguration: Benutzer können die Plugin-Optionen über das WordPress-Adminpanel konfigurieren, um ihre Karten entsprechend ihren Anforderungen anzupassen.

Das Plugin wurde von Homepage-nach-Preis.de entwickelt und steht unter der GNU General Public License Version 3 (GPLv3), was bedeutet, dass es kostenlos verwendet und modifiziert werden kann, solange die Lizenzbedingungen eingehalten werden.

Download: [sdm_download id=”8174″ fancy=”0″]

Github: https://github.com/HNP-Christopher-Rohde/hnp-openstreetmap-wordpress-plugin/tree/main/hnp_openstreetmap
Quellcode:

<?php
/*
  Plugin Name: HNP OpenStreetMap Shortcode
  Description: Creates a frontend OpenStreetMap map with a pin using a shortcode
  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
 */

// Security check to prevent direct access to the plugin file
defined('ABSPATH') or die('No script kiddies please!');

// Function to enqueue Leaflet library
function hnp_openmaps_enqueue_leaflet_scripts() {
    // Define a version number for your CSS file
    $version = '1.9.4';

    // Check if Leaflet CSS is not already enqueued
    if (!wp_style_is('leaflet-css')) {
        // Enqueue Leaflet CSS with the defined version
        wp_enqueue_style('leaflet-css', plugin_dir_url(__FILE__) . 'leaflet/leaflet.css', array(), $version);
    }

    // Check if Leaflet JavaScript is not already enqueued
    if (!wp_script_is('leaflet-js')) {
        // Enqueue Leaflet JavaScript with the defined version
        wp_enqueue_script('leaflet-js', plugin_dir_url(__FILE__) . 'leaflet/leaflet.js', array(), $version, true);
    }
}
add_action('wp_enqueue_scripts', 'hnp_openmaps_enqueue_leaflet_scripts');

// Function to display OpenStreetMap maps with a pin
function hnp_openmaps_display_map_with_pin() {
    // Load options and sanitize address
    $raw_address = get_option('hnp_openmaps_map_address', 'Hardenbergpl. 8, 10787 Berlin, Germany');
    $clean_address = sanitize_text_field($raw_address);

    // Load options and sanitize marker name
    $marker_name = get_option('hnp_openmaps_map_name', 'Berlin Zoological Garden'); 

    // Load zoom level, map style, height, and width of the map
    $zoom = get_option('hnp_openmaps_map_zoom', 12);
    $style = get_option('hnp_openmaps_map_style', 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png');
    $height = get_option('hnp_openmaps_map_height', '400px');
    $width = get_option('hnp_openmaps_map_width', '100%');

    // JavaScript variable for map initialization and adding markers
    $map = "
        <script>
            document.addEventListener('DOMContentLoaded', function() {
    ";

    // Split address into individual parts and encode
    $address_parts = explode(',', $clean_address);
    $encoded_address_parts = array_map('urlencode', $address_parts);
    $encoded_address = implode(',', $encoded_address_parts);

    // Construct Nominatim URL
    $nominatim_url = "https://nominatim.openstreetmap.org/search?format=json&q={$encoded_address}";

    // Get geocoding data from Nominatim
    $response = wp_remote_get($nominatim_url);

    // Check if the request was successful
    if (!is_wp_error($response) && wp_remote_retrieve_response_code($response) === 200) {
        $data = json_decode(wp_remote_retrieve_body($response), true);

        // Check if geocoding results were obtained
        if (!empty($data)) {
            $latitude = $data[0]['lat'];
            $longitude = $data[0]['lon'];

            // Initialize map with center at marker coordinates
            $map .= "
                var hnp_openmaps_map = L.map('hnp_openmaps_map').setView([$latitude, $longitude], $zoom);
            ";

            // Add tiles to the map
            $map .= "
                L.tileLayer('$style', {
                    attribution: '&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors'
                }).addTo(hnp_openmaps_map);
            ";

            // Add marker to the map
            $map .= "
                L.marker([$latitude, $longitude]).addTo(hnp_openmaps_map).bindPopup('" . esc_js($clean_address) . "').bindTooltip('" . esc_js($marker_name) . "');
                console.log('Geocoding successful for address:', " . wp_json_encode($clean_address) . ");
            ";
        } else {
            // Error retrieving geocoding data
            error_log("Error retrieving geocoding data for address: $clean_address");
            $map .= "
                console.log('Error retrieving geocoding data for address:', " . wp_json_encode($clean_address) . ");
            ";
        }
    } else {
        // Error retrieving geocoding data
        error_log("Error retrieving geocoding data for address: $clean_address");
        $map .= "
            console.log('Error retrieving geocoding data for address:', " . wp_json_encode($clean_address) . ");
        ";
    }

    // Add JavaScript end
    $map .= "
            });
        </script>
    ";

    // Return map div and JavaScript
    return '<div id="hnp_openmaps_map" style="height: ' . esc_attr($height) . '; width: ' . esc_attr($width) . ';"></div>' . $map;
}

// Register shortcode
add_shortcode('hnp_openmaps_display_map_with_pin', 'hnp_openmaps_display_map_with_pin');

// Function to add plugin options to the main menu
function hnp_openmaps_add_plugin_options_page() {
    // Check permission
    if (current_user_can('manage_options')) {
        add_menu_page(
            'HNP OpenStreetMap Settings',
            'HNP OpenStreetMap',
            'manage_options',
            'hnp-openmaps-osm-settings',
            'hnp_openmaps_render_plugin_options_page',
            plugin_dir_url(__FILE__) . 'img/hnp-favi.png' 
        );
    }
}
add_action('admin_menu', 'hnp_openmaps_add_plugin_options_page');

// Add settings link to plugin on the Plugins page
function hnp_openmaps_add_settings_link($links) {
    $settings_link = '<a href="admin.php?page=hnp-openmaps-osm-settings">' . __('Settings') . '</a>';
    array_unshift($links, $settings_link); // Add the settings link at the beginning of the array
    return $links;
}
add_filter('plugin_action_links_' . plugin_basename(__FILE__), 'hnp_openmaps_add_settings_link');


// Function to render plugin options page
function hnp_openmaps_render_plugin_options_page() {
    ?>
    <div class="wrap">
        <h1>HNP OpenStreetMap Settings</h1>
        <form method="post" action="options.php">
            <?php settings_fields('hnp_openmaps_osm_settings_group'); ?>
            <?php do_settings_sections('hnp-openmaps-osm-settings'); ?>
            <?php 
                // Add nonce
                wp_nonce_field('hnp_openmaps_osm_settings_nonce', 'hnp_openmaps_osm_settings_nonce'); 
            ?>
            <?php submit_button(); ?>
        </form>
    </div>
    <?php
}


// Function to register plugin options
function hnp_openmaps_register_plugin_options() {
    // Adresse
    add_settings_section(
        'hnp_openmaps_osm_address_section',
        'Address',
        'hnp_openmaps_osm_address_section_callback',
        'hnp-openmaps-osm-settings'
    );
    add_settings_field(
        'hnp_openmaps_map_address',
        'Address',
        'hnp_openmaps_map_address_callback',
        'hnp-openmaps-osm-settings',
        'hnp_openmaps_osm_address_section'
    );
    register_setting('hnp_openmaps_osm_settings_group', 'hnp_openmaps_map_address');

    // Name
    add_settings_section(
        'hnp_openmaps_osm_name_section',
        'Name',
        'hnp_openmaps_osm_name_section_callback',
        'hnp-openmaps-osm-settings'
    );
    add_settings_field(
        'hnp_openmaps_map_name',
        'Name',
        'hnp_openmaps_map_name_callback',
        'hnp-openmaps-osm-settings',
        'hnp_openmaps_osm_name_section'
    );
    register_setting('hnp_openmaps_osm_settings_group', 'hnp_openmaps_map_name');

    // Karten-Zoom
    add_settings_section(
        'hnp_openmaps_osm_zoom_section',
        'Map Zoom',
        'hnp_openmaps_osm_zoom_section_callback',
        'hnp-openmaps-osm-settings'
    );
    add_settings_field(
        'hnp_openmaps_map_zoom',
        'Map Zoom',
        'hnp_openmaps_map_zoom_callback',
        'hnp-openmaps-osm-settings',
        'hnp_openmaps_osm_zoom_section'
    );
    register_setting('hnp_openmaps_osm_settings_group', 'hnp_openmaps_map_zoom');

    // Kartenstil
    add_settings_section(
        'hnp_openmaps_osm_style_section',
        'Map Style',
        'hnp_openmaps_osm_style_section_callback',
        'hnp-openmaps-osm-settings'
    );
    add_settings_field(
        'hnp_openmaps_map_style',
        'Map Style',
        'hnp_openmaps_map_style_callback',
        'hnp-openmaps-osm-settings',
        'hnp_openmaps_osm_style_section'
    );
    register_setting('hnp_openmaps_osm_settings_group', 'hnp_openmaps_map_style');

    add_settings_section(
        'hnp_openmaps_osm_height_section',
        'Map Height',
        'hnp_openmaps_osm_height_section_callback',
        'hnp-openmaps-osm-settings'
    );
    add_settings_field(
        'hnp_openmaps_map_height',
        'Map Height',
        'hnp_openmaps_map_height_callback',
        'hnp-openmaps-osm-settings',
        'hnp_openmaps_osm_height_section'
    );
    register_setting('hnp_openmaps_osm_settings_group', 'hnp_openmaps_map_height');

    add_settings_section(
        'hnp_openmaps_osm_width_section',
        'Map Width',
        'hnp_openmaps_osm_width_section_callback',
        'hnp-openmaps-osm-settings'
    );
    add_settings_field(
        'hnp_openmaps_map_width',
        'Map Width',
        'hnp_openmaps_map_width_callback',
        'hnp-openmaps-osm-settings',
        'hnp_openmaps_osm_width_section'
    );
    register_setting('hnp_openmaps_osm_settings_group', 'hnp_openmaps_map_width');

    add_settings_section(
        'hnp_openmaps_shortcode_section',
        'Shortcode',
        'hnp_openmaps_shortcode_section_callback',
        'hnp-openmaps-osm-settings'
    );
}


// Callback functions for each option
function hnp_openmaps_osm_address_section_callback() {
    echo '<p>Enter the address to be displayed on the map. <br>Format: Streetname + Housenumber, City Name + ZIP Code, Country <br>(Separate each part with a comma)</p>';
}
function hnp_openmaps_map_address_callback() {
    $address = get_option('hnp_openmaps_map_address', 'Hardenbergpl. 8, 10787 Berlin, Germany');
    echo '<input type="text" name="hnp_openmaps_map_address" value="' . esc_attr($address) . '" />';
}

function hnp_openmaps_osm_name_section_callback() {
    echo '<p>Enter the name for the marker to be displayed on the map.</p>';
}
function hnp_openmaps_map_name_callback() {
    $name = get_option('hnp_openmaps_map_name', 'Berlin Zoological Garden');
    echo '<input type="text" name="hnp_openmaps_map_name" value="' . esc_attr($name) . '" />';
}

function hnp_openmaps_osm_zoom_section_callback() {
    echo '<p>Set the zoom level of the map.</p>';
}
function hnp_openmaps_map_zoom_callback() {
    $zoom = get_option('hnp_openmaps_map_zoom', 12);
    echo '<input type="number" name="hnp_openmaps_map_zoom" value="' . esc_attr($zoom) . '" />';
}
function hnp_openmaps_osm_style_section_callback() {
    echo '<p>Select the map style.</p>';
}
function hnp_openmaps_map_style_callback() {
    $style = get_option('hnp_openmaps_map_style', 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png');
    $styles = array(
        'Standard (OpenStreetMap)' => 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
        'Hot' => 'https://{s}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png',
        'Cycle' => 'https://tile.thunderforest.com/cycle/{z}/{x}/{y}.png',
        'Transport' => 'https://{s}.tile.thunderforest.com/transport/{z}/{x}/{y}.png'
        // More styles can be added here
    );
    echo '<select name="hnp_openmaps_map_style">';
    foreach ($styles as $label => $url) {
        echo '<option value="' . esc_attr($url) . '" ' . selected($style, $url, false) . '>' . esc_html($label) . '</option>';
    }
    echo '</select>';
}

function hnp_openmaps_osm_height_section_callback() {
    echo '<p>Set the height of the map.</p>';
}
function hnp_openmaps_map_height_callback() {
    $height = get_option('hnp_openmaps_map_height', '400px');
    echo '<input type="text" name="hnp_openmaps_map_height" value="' . esc_attr($height) . '" />';
}
function hnp_openmaps_osm_width_section_callback() {
    echo '<p>Set the width of the map.</p>';
}
function hnp_openmaps_map_width_callback() {
    $width = get_option('hnp_openmaps_map_width', '100%');
    echo '<input type="text" name="hnp_openmaps_map_width" value="' . esc_attr($width) . '" />';
}
function hnp_openmaps_shortcode_section_callback() {
    echo '<p>Shortcode: &#x5B;hnp_openmaps_display_map_with_pin]</p>';
}

// Register plugin options and security measures
add_action('admin_init', 'hnp_openmaps_register_plugin_options');

// Security measures: Nonce verification for options update
function hnp_openmaps_validate_settings($input) {
    return $input; // Simply return the input, no further validation here
}

// Security measures: Nonce verification and save options
function hnp_openmaps_register_security_options() {
    // Check if the current page is our plugin options page
    if (isset($_POST['option_page']) && $_POST['option_page'] == 'hnp_openmaps_osm_settings_group') {
        // Check if the nonce is set and valid
        if (!isset($_POST['hnp_openmaps_osm_settings_nonce']) || !wp_verify_nonce($_POST['hnp_openmaps_osm_settings_nonce'], 'hnp_openmaps_osm_settings_nonce')) {
            // Unauthorized request, do not save options
            wp_die('Unauthorized request.'); // Output error message for unauthorized requests
        }

        // Save options
        update_option('hnp_openmaps_map_address', $_POST['hnp_openmaps_map_address']);
        update_option('hnp_openmaps_map_name', $_POST['hnp_openmaps_map_name']);
        update_option('hnp_openmaps_map_zoom', $_POST['hnp_openmaps_map_zoom']);
        update_option('hnp_openmaps_map_style', $_POST['hnp_openmaps_map_style']);
        update_option('hnp_openmaps_map_height', $_POST['hnp_openmaps_map_height']);
        update_option('hnp_openmaps_map_width', $_POST['hnp_openmaps_map_width']);
    }
}
add_action('admin_init', 'hnp_openmaps_register_security_options');

Der Beitrag HNP OpenStreetMap kostenloses Plugin erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Dynamische Templates in WordPress erzeugen & einbinden

Homepage-nach-Preis — Sun, 07 Apr 2024 16:20:29 +0000

Das “HNP Dyn Template” Plugin ermöglicht es Benutzern, zwischen verschiedenen Vorlagen für eine bestimmte Seite oder einen Beitrag zu wählen. Durch Hinzufügen von Shortcodes können Benutzer auf einfache Weise zwischen verschiedenen Templates hin- und herwechseln, ohne den Code manuell bearbeiten zu müssen.

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):


    
        
        
    
    
    
    
    
    
    
Template 1 Datei:



    Template 1
    Dies ist der Inhalt von Template 1.



Template 2 Datei:



    Template 2
    Dies ist der Inhalt von Template 2.



WordPress Plugin Code mit Ajax:

    
        
        
    
    
    
    
     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.

Ajax und WP-Ajax verstehen – Code Beispiel

Homepage-nach-Preis — Sat, 06 Apr 2024 04:00:17 +0000

AJAX (Asynchronous JavaScript and XML) ist eine Technik, die es ermöglicht, Daten zwischen dem Browser des Benutzers und dem Server auszutauschen, ohne die gesamte Webseite neu zu laden. Dies ermöglicht eine verbesserte Benutzererfahrung, da Inhalte dynamisch aktualisiert werden können, ohne die Seite zu verlassen. Stellen wir uns ein Restaurant vor und einen Kunden, der Kunde erhält seine Bestellung, ohne zum Restaurant fahren zu müssen, also vergleichbar mit einem Lieferanten. AJAX ist die Verbindung zwischen Server und Client, ein praktischer Helfer.

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.

Bild austauschen bei Maus Hover Funktion

Homepage-nach-Preis — Thu, 04 Apr 2024 08:03:24 +0000

Einfache Funktion, um ein Bild auszuwechseln, sobald sich die Maus über dem Bild befindet. Also eine Hover-Change-Image Funktion.

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.

HNP Variable CSS WordPress Plugin

Homepage-nach-Preis — Thu, 04 Apr 2024 03:18:54 +0000

Das HNP Variable CSS WordPress Plugin ist eine Erweiterung für WordPress-Websites, die eine einfache Möglichkeit bietet, CSS-Variablen oder CSS-Custom-Properties zu verwenden. Nach der Installation und Aktivierung des Plugins können Sie Ihre gewünschten Werte in den Plugin-Optionen festlegen und anschließend diese festgelegten CSS-Variablen in Ihrem Theme verwenden. Dadurch können Sie Ihre Website modern gestalten und zukunftssicher machen, oder sogar das Plugin für Funktionen wie einen Dark Mode nutzen (diese Funktion erfordert möglicherweise zusätzliche Anpassungen).

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.

Temporäre Produkte WooCommerce Plugin

Homepage-nach-Preis — Thu, 04 Apr 2024 03:14:39 +0000

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.