Allgemein News Kategorie - Homepage-nach-Preis

Simple Blockchain Beispiel mit Miner

Homepage-nach-Preis — Fri, 06 Sep 2024 16:17:14 +0000

Wie funktioniert eine Kryptowährung bzw. eine Blockchain mit einem Proof of Work Mechanismus (Mining).

Ihr Gerät unterstützt eine Wiedergabe des Videos nicht.

Github: https://github.com/HNP-Christopher-Rohde/hnp-example-blockchain-with-miner

Blockchain

Die Blockchain in diesem System ist eine auf Blöcken basierende Kette, die kryptografisch gesichert ist. Jeder Block enthält folgende Informationen:

Index: Die Position des Blocks in der Kette.
Zeitstempel: Der Zeitpunkt, zu dem der Block erstellt wurde (in Unix-Zeit).
Daten: Die im Block gespeicherten Informationen (in binärer Form).
Vorheriger Hash: Der Hash des vorhergehenden Blocks, der die Verbindung zu diesem sicherstellt.
Hash: Der eigene Hash des Blocks, der durch den Hashing-Algorithmus SHA-256 berechnet wird.
Nonce: Eine Zahl, die während des Minings variiert wird, um den Hash zu finden, der den Anforderungen der Schwierigkeit entspricht.

Die Blockchain wird mit einem Genesis-Block initialisiert. Jeder neue Block wird durch einen Mining-Prozess erstellt, der den Hash so anpasst, dass er den Schwierigkeitsanforderungen (Difficulty) entspricht, d. h. der Hash muss mit einer bestimmten Anzahl von Nullen beginnen. Die Schwierigkeit passt sich dynamisch an, basierend auf der Zeit, die für die Erstellung der letzten Blöcke benötigt wurde.

Validität der Blockchain:

Jeder Block in der Kette wird überprüft, um sicherzustellen, dass der Hash korrekt ist und der Hash des vorherigen Blocks mit dem gespeicherten previous_hash übereinstimmt.
Es wird außerdem geprüft, ob der Block die Schwierigkeit (Difficulty) erfüllt, bevor er zur Kette hinzugefügt wird.

Die Blockchain speichert die Blöcke auf der Festplatte (z. B. in der Datei blockchain.json) und bietet APIs für den Empfang und das Senden neuer Blöcke zwischen Peers.

Blockchain:

use serde::{Serialize, Deserialize};
use std::collections::VecDeque;
use std::fs;
use sha2::Digest;
use hex;
use std::time::{SystemTime, UNIX_EPOCH};
use reqwest;
use warp::Filter;
use log::{info, error};
use std::env;
use std::sync::{Arc, Mutex};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Block {
    pub index: u64,
    pub timestamp: u64,
    pub data: Vec<u8>,
    pub previous_hash: String,
    pub hash: String,
    pub nonce: u64,
}

impl Block {
    pub fn new(index: u64, data: Vec<u8>, previous_hash: String) -> Self {
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
        let mut block = Block {
            index,
            timestamp,
            data,
            previous_hash,
            hash: String::new(),
            nonce: 0,
        };
        block.hash = block.calculate_hash();
        info!("Created new block: {:?}", block);
        block
    }

    pub fn calculate_hash(&self) -> String {
        let mut hasher = sha2::Sha256::new();
        hasher.update(format!("{}{}{}{}{}", self.index, self.timestamp, hex::encode(&self.data), self.previous_hash, self.nonce));
        let result = hasher.finalize();
        hex::encode(result)
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Blockchain {
    pub chain: VecDeque<Block>,
    pub difficulty: u32,
    pub adjustment_interval: u64,
    pub target_block_time: u64,
    pub last_difficulty_update: u64,
}

impl Blockchain {
    pub fn new(difficulty: u32, adjustment_interval: u64, target_block_time: u64) -> Self {
        let mut chain = VecDeque::new();
        chain.push_back(create_genesis_block());
        info!("Blockchain initialized with genesis block");
        Blockchain {
            chain,
            difficulty,
            adjustment_interval,
            target_block_time,
            last_difficulty_update: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
        }
    }

    pub fn add_block(&mut self, data: Vec<u8>) {
        let previous_block = self.chain.back().unwrap();
        let new_block = mine_block(previous_block, data, self.difficulty);
        info!("Adding new block: {:?}", new_block);
        self.chain.push_back(new_block);
    
        // Update difficulty if needed
        if (self.chain.len() as u64) % self.adjustment_interval == 0 {
            self.update_difficulty_based_on_time();
        }
    
        if let Err(e) = self.save_to_file("blockchain.json") {
            error!("Failed to save blockchain after adding block: {}", e);
        }
    }
    
    pub fn is_valid(&self) -> bool {
        for i in 1..self.chain.len() {
            let current = &self.chain[i];
            let previous = &self.chain[i - 1];

            if current.hash != current.calculate_hash() {
                error!("Block {} has invalid hash", current.index);
                return false;
            }

            if current.previous_hash != previous.hash {
                error!("Block {} has invalid previous hash", current.index);
                return false;
            }

            if !meets_difficulty(&current.hash, self.difficulty) {
                error!("Block {} does not meet difficulty", current.index);
                return false;
            }
        }
        true
    }

    pub fn save_to_file(&self, filename: &str) -> std::io::Result<()> {
        let serialized = serde_json::to_string(self)
            .expect("Serialization failed");
        fs::write(filename, serialized).map_err(|e| {
            error!("Failed to write blockchain to file: {}", e);
            e
        })?;
        info!("Blockchain saved to file: {}", filename);
        Ok(())
    }
    
    pub fn load_from_file(filename: &str) -> std::io::Result<Self> {
        match fs::read_to_string(filename) {
            Ok(data) if !data.is_empty() => {
                match serde_json::from_str::<Blockchain>(&data) {
                    Ok(blockchain) => {
                        info!("Blockchain loaded from file: {}", filename);
                        Ok(blockchain)
                    }
                    Err(e) => {
                        info!("Failed to deserialize blockchain from file, creating a new one: {}", e);
                        let (difficulty, adjustment_interval, target_block_time) = load_config();
                        Ok(Blockchain::new(difficulty, adjustment_interval, target_block_time))
                    }
                }
            }
            _ => {
                info!("Blockchain file is empty or not found. Creating a new blockchain.");
                let (difficulty, adjustment_interval, target_block_time) = load_config();
                Ok(Blockchain::new(difficulty, adjustment_interval, target_block_time))
            }
        }
    }
    
    pub async fn broadcast_new_block(&self, block: &Block, peers: &[&str]) -> reqwest::Result<()> {
        for peer in peers {
            let url = format!("{}/new-block", peer);
            info!("Broadcasting new block to peer: {}", url);
            let result = reqwest::Client::new()
                .post(&url)
                .json(&block)
                .send()
                .await;

            match result {
                Ok(_) => info!("Successfully sent block to {}", url),
                Err(e) => error!("Failed to send block to {}: {:?}", url, e),
            }
        }
        Ok(())
    }

    pub fn add_block_from_request(&mut self, block: Block) -> bool {
        let previous_block = self.chain.back().unwrap();

        info!("Received block: {:?}", block);
        info!("Last block in chain: {:?}", previous_block);

        // Additional validation for the timestamp
        if block.timestamp <= previous_block.timestamp {
            error!("Block timestamp is not valid");
            return false;
        }

        let is_valid = block.index == previous_block.index + 1
            && block.previous_hash == previous_block.hash
            && block.hash == block.calculate_hash()
            && meets_difficulty(&block.hash, self.difficulty);
        
        if is_valid {
            info!("Valid block received and added to chain");
            self.chain.push_back(block);
            if let Err(e) = self.save_to_file("blockchain.json") {
                error!("Failed to save blockchain after adding block: {}", e);
            }
        } else {
            error!("Invalid block received: \n\
                    Index: {} \n\
                    Previous Hash: {} \n\
                    Expected Previous Hash: {} \n\
                    Hash: {} \n\
                    Calculated Hash: {} \n\
                    Difficulty Met: {}",
                block.index,
                block.previous_hash,
                previous_block.hash,
                block.hash,
                block.calculate_hash(),
                meets_difficulty(&block.hash, self.difficulty));
        }
        
        is_valid
    }
    
    pub fn update_difficulty_based_on_time(&mut self) {
        let length = self.chain.len() as u64;
        info!("Chain length: {}", length);
        
        if length >= self.adjustment_interval {
            let interval_start_block = &self.chain[self.chain.len() - self.adjustment_interval as usize];
            let interval_end_block = self.chain.back().unwrap();
    
            let time_taken = interval_end_block.timestamp - interval_start_block.timestamp;
            let expected_time = self.adjustment_interval * self.target_block_time;
    
            info!("Time taken for the last {} blocks: {} seconds", self.adjustment_interval, time_taken);
            info!("Expected time for the last {} blocks: {} seconds", self.adjustment_interval, expected_time);
    
            if time_taken < expected_time / 2 {
                self.difficulty += 1;
                info!("Difficulty increased to {}", self.difficulty);
            } else if time_taken > expected_time * 2 {
                if self.difficulty > 1 {
                    self.difficulty -= 1;
                    info!("Difficulty decreased to {}", self.difficulty);
                }
            } else {
                info!("Difficulty remains at {}", self.difficulty);
            }
    
            // Update the last difficulty update timestamp
            self.last_difficulty_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
        } else {
            info!("Not enough blocks to adjust difficulty.");
        }
    }
    
    
    pub fn update_difficulty(&mut self, new_difficulty: u32) {
        self.difficulty = new_difficulty;
        info!("Difficulty updated to {}", new_difficulty);
        if let Err(e) = self.save_to_file("blockchain.json") {
            error!("Failed to save blockchain after updating difficulty: {}", e);
        }
    }
}

pub fn create_genesis_block() -> Block {
    Block::new(0, "Genesis Block".as_bytes().to_vec(), "0".to_string())
}

fn meets_difficulty(hash: &str, difficulty: u32) -> bool {
    let target = vec![0u8; difficulty as usize];
    let hash_bytes = hex::decode(hash).expect("Hex decode failed");
    hash_bytes.len() >= target.len() && hash_bytes.starts_with(&target)
}

fn mine_block(previous_block: &Block, data: Vec<u8>, difficulty: u32) -> Block {
    let mut new_block = Block::new(previous_block.index + 1, data.clone(), previous_block.hash.clone());

    let mut attempt = 0;

    while !meets_difficulty(&new_block.hash, difficulty) {
        new_block.nonce += 1;
        new_block.hash = new_block.calculate_hash();

        attempt += 1;
        if attempt % 100 == 0 {
            println!("Attempt {}: Trying hash: {}", attempt, new_block.hash);
        }
    }

    new_block
}


fn load_config() -> (u32, u64, u64) {
    use serde::Deserialize;
    #[derive(Deserialize)]
    struct Config {
        initial_difficulty: u32,
        adjustment_interval: u64,
        target_block_time: u64,
    }

    let data = fs::read_to_string("config.json").expect("Unable to read config file");
    let config: Config = serde_json::from_str(&data).expect("Unable to parse config file");
    (config.initial_difficulty, config.adjustment_interval, config.target_block_time)
}

#[tokio::main]
async fn main() {
    env::set_var("RUST_LOG", "info");
    env_logger::init();

    let (initial_difficulty, adjustment_interval, target_block_time) = load_config();
    let blockchain = Arc::new(Mutex::new(
        Blockchain::load_from_file("blockchain.json").unwrap_or_else(|_| Blockchain::new(initial_difficulty, adjustment_interval, target_block_time))
    ));

    let blockchain_filter = warp::any().map(move || blockchain.clone());

    let new_block = warp::post()
        .and(warp::path("new-block"))
        .and(warp::body::json())
        .and(blockchain_filter.clone())
        .map(|block: Block, blockchain: Arc<Mutex<Blockchain>>| {
            let mut blockchain = blockchain.lock().unwrap();
            let response = if blockchain.add_block_from_request(block) {
                "Block added successfully"
            } else {
                "Invalid block"
            };
            response
        });

    let difficulty = warp::get()
        .and(warp::path("difficulty"))
        .map(move || format!("Difficulty: {}", initial_difficulty));

    let set_difficulty = warp::post()
        .and(warp::path("set-difficulty"))
        .and(warp::body::json())
        .and(blockchain_filter.clone())
        .map(|_new_difficulty: u32, _blockchain: Arc<Mutex<Blockchain>>| {
            // Ignoring difficulty change here, as it's handled externally
            format!("Difficulty updated to {}", _new_difficulty)
        });

    let last_block = warp::get()
        .and(warp::path("last-block"))
        .and(blockchain_filter.clone())
        .map(|blockchain: Arc<Mutex<Blockchain>>| {
            let blockchain = blockchain.lock().unwrap();
            let last_block = blockchain.chain.back().cloned().unwrap_or_else(|| create_genesis_block());
            warp::reply::json(&last_block)
        });

    let routes = new_block.or(difficulty).or(set_difficulty).or(last_block);

    info!("Starting server at http://127.0.0.1:8000");
    warp::serve(routes).run(([127, 0, 0, 1], 8000)).await;
}

Miner

Der Miner ist für die Erstellung neuer Blöcke in der Blockchain verantwortlich. Er arbeitet nach einem Proof-of-Work-Mechanismus, bei dem der Miner eine nonce-Nummer anpasst, bis ein gültiger Hash gefunden wird, der den Schwierigkeitsanforderungen entspricht.

Ablauf des Mining-Prozesses:

Der Miner fragt den letzten Block der Blockchain von einem Server ab.
Der Miner fragt die aktuelle Schwierigkeit vom Server ab.
Ein neuer Block wird erstellt, indem die Daten des vorherigen Blocks verwendet werden, sowie neue Transaktionsdaten.
Der Miner berechnet den Hash des neuen Blocks durch Anpassung der nonce, bis der Hash die Schwierigkeit erfüllt (d. h., der Hash beginnt mit einer bestimmten Anzahl von Nullen).
Sobald ein gültiger Block gefunden wurde, wird er an den Server gesendet, der ihn zur Blockchain hinzufügt.

Der Mining-Prozess läuft in einem Loop, sodass kontinuierlich nach neuen Blöcken gesucht wird, die der Blockchain hinzugefügt werden können.

use serde::{Serialize, Deserialize};
use sha2::{Sha256, Digest};
use std::time::{SystemTime, UNIX_EPOCH};
use reqwest;
use hex;
use anyhow::{Result, Context};
use tokio::task;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Block {
    pub index: u64,
    pub timestamp: u64,
    pub data: Vec<u8>,
    pub previous_hash: String,
    pub hash: String,
    pub nonce: u64,
}

impl Block {
    pub fn new(index: u64, data: Vec<u8>, previous_hash: String) -> Self {
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
        let mut block = Block {
            index,
            timestamp,
            data,
            previous_hash,
            hash: String::new(),
            nonce: 0,
        };
        block.hash = block.calculate_hash();
        block
    }

    pub fn calculate_hash(&self) -> String {
        let mut hasher = Sha256::new();
        hasher.update(format!("{}{}{}{}{}", self.index, self.timestamp, hex::encode(&self.data), self.previous_hash, self.nonce));
        let result = hasher.finalize();
        hex::encode(result)
    }
}

fn meets_difficulty(hash: &str, difficulty: u32) -> bool {
    let target = vec![0u8; difficulty as usize];
    let hash_bytes = hex::decode(hash).expect("Hex decode failed");
    hash_bytes.starts_with(&target)
}

async fn mine_block(previous_block: &Block, data: Vec<u8>, difficulty: u32) -> Block {
    let mut new_block = Block::new(previous_block.index + 1, data.clone(), previous_block.hash.clone());

    // Parallel mining using multiple threads
    let mining_task = task::spawn_blocking(move || {
        let mut attempt = 0;
        while !meets_difficulty(&new_block.hash, difficulty) {
            new_block.nonce += 1;
            new_block.hash = new_block.calculate_hash();

            attempt += 1;
            if attempt % 100 == 0 {
                println!("Attempt {}: Trying hash: {}", attempt, new_block.hash);
            }
        }

        new_block
    });

    mining_task.await.unwrap()
}

async fn get_last_block_from_server() -> Result<Block> {
    let client = reqwest::Client::new();
    let url = "http://localhost:8000/last-block";

    let res = client.get(url)
        .send()
        .await
        .context("Failed to send request to get last block")?;

    let last_block: Block = res.json().await
        .context("Failed to parse last block")?;
    Ok(last_block)
}

async fn send_block_to_server(block: &Block) -> Result<()> {
    let client = reqwest::Client::new();
    let url = "http://localhost:8000/new-block";

    println!("Sending block: {:?}", block);

    let res = client.post(url)
        .json(block)
        .send()
        .await
        .context("Failed to send request to post new block")?;

    let status = res.status();
    let body = res.text().await
        .context("Failed to read response text")?;

    if status.is_success() {
        println!("Block successfully sent to server.");
    } else {
        println!("Failed to send block to server: {} - {}", status, body);
    }

    Ok(())
}

async fn get_difficulty_from_server() -> Result<u32> {
    let client = reqwest::Client::new();
    let url = "http://localhost:8000/difficulty";

    let res = client.get(url)
        .send()
        .await
        .context("Failed to send request to get difficulty")?;

    let difficulty_str = res.text().await
        .context("Failed to read difficulty response")?;
    let difficulty = difficulty_str.trim_start_matches("Difficulty: ")
        .parse::<u32>()
        .context("Failed to parse difficulty")?;

    Ok(difficulty)
}

async fn display_difficulty() -> Result<()> {
    let difficulty = get_difficulty_from_server().await
        .context("Error retrieving difficulty from server")?;

    println!("Current Difficulty: {}", difficulty);

    Ok(())
}

#[tokio::main]
async fn main() -> Result<()> {
    loop {
        // Anzeige der aktuellen Schwierigkeit
        display_difficulty().await
            .context("Error displaying difficulty")?;

        // Hol die Schwierigkeit vom Server
        let difficulty = get_difficulty_from_server().await
            .context("Error retrieving difficulty from server")?;

        // Hol den letzten Block vom Server
        let previous_block = get_last_block_from_server().await
            .context("Error retrieving last block from server")?;

        let data = b"Block data".to_vec();
        let new_block = mine_block(&previous_block, data, difficulty).await;

        send_block_to_server(&new_block).await
            .context("Error sending block to server")?;

        // Warte eine gewisse Zeit, bevor der nächste Block erstellt wird
        tokio::time::sleep(tokio::time::Duration::from_secs(0)).await; // Wartezeit erhöht
    }
}

Der Beitrag Simple Blockchain Beispiel mit Miner erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von 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 SHORTCODE Tool: Eine Revolution für WordPress

Homepage-nach-Preis — Fri, 26 Apr 2024 19:13:58 +0000

Unbegrenzte Anpassung mit dem HNP WIN SHORTCODE Tool: Eine Revolution für WordPress

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.

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.

HNP Bewertungssystem Plugin

Homepage-nach-Preis — Fri, 05 Apr 2024 12:24:30 +0000

HNP Rating Form – Revolutionieren Sie das Bewertungserlebnis auf Ihrer WordPress-Website

Das HNP Rating Form Plugin ist die ultimative Lösung, um Ihrer WordPress-Website eine hochmoderne Bewertungsfunktion hinzuzufügen. Mit einer Vielzahl von leistungsstarken Funktionen und einem benutzerfreundlichen Interface bietet dieses Plugin eine nahtlose Möglichkeit, das Feedback Ihrer Benutzer zu sammeln und zu verwalten. Hier sind einige herausragende Merkmale, die das HNP Rating Form Plugin zu bieten hat:

Benutzerfreundliches Backend-Interface

Das Plugin bietet eine intuitive und benutzerfreundliche Oberfläche im WordPress-Backend, über die Sie mühelos alle Aspekte Ihres Bewertungssystems verwalten können. Von der Genehmigung von Bewertungen bis hin zur Anpassung der Einstellungen haben Sie alles im Griff.

Sicherheitsfunktionen zum Schutz vor Missbrauch

Mit integrierten Sicherheitsfunktionen wie Captcha können Sie Ihr Bewertungssystem vor Spam und Missbrauch schützen. Aktivieren Sie Captcha, um sicherzustellen, dass nur echte Benutzer Bewertungen abgeben können, ohne von unerwünschten Inhalten überflutet zu werden.

Flexible Einstellungsoptionen

Passen Sie das Bewertungssystem an Ihre spezifischen Anforderungen an, indem Sie Optionen wie die Anzeige des Bewertungsdatums, die automatische Freischaltung von Bewertungen und die Anzahl der angezeigten Sterne anpassen. Mit dem HNP Rating Form Plugin haben Sie die volle Kontrolle über Ihre Bewertungen.

Leistungsstarke Shortcodes für eine nahtlose Integration

Nutzen Sie eine Vielzahl von Shortcodes, um Bewertungsformulare und -ergebnisse nahtlos in Ihre Website zu integrieren. Mit Shortcodes können Sie Gesamtbewertungen, Einzelbewertungen und benutzerdefinierte Bewertungsformulare mit Leichtigkeit anzeigen.

Vollständig anpassbares Design

Passen Sie das Aussehen und Verhalten Ihres Bewertungssystems mühelos an, um sicherzustellen, dass es perfekt zu Ihrem Website-Design passt. Mit benutzerdefinierten CSS-Styles können Sie das Aussehen Ihres Bewertungssystems ganz nach Ihren Wünschen gestalten.

Unterstützung für strukturierte Daten (JSON-LD)

Verbessern Sie die Sichtbarkeit Ihrer Website in den Suchergebnissen, indem Sie strukturierte Daten für Rich Snippets hinzufügen. Das Plugin generiert automatisch strukturierte Daten für Ihre Bewertungen, um Suchmaschinen zu helfen, Ihre Inhalte besser zu verstehen.

Das HNP Rating Form Plugin bietet Ihnen alles, was Sie benötigen, um das Benutzerengagement zu steigern, wertvolle Rückmeldungen zu sammeln und das Vertrauen Ihrer Besucher zu stärken. Holen Sie sich noch heute das Plugin und bringen Sie Ihre Bewertungen auf die nächste Stufe!

Erwecken Sie Ihre Website zum Leben und geben Sie Ihren Benutzern eine Stimme mit dem HNP Rating Form Plugin!

Mehr Lesen & Download:

https://shop.homepage-nach-preis.de/produkt/hnp-bewertungssystem-wordpress-plugin/

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

HNP SQL-Database Tool für WordPress als Plugin

Homepage-nach-Preis — Sun, 31 Mar 2024 00:35:32 +0000

Einleitung: Die effiziente Verwaltung von Datenbankeinträgen ist entscheidend für die reibungslose Funktion einer WordPress-Website. Von der Aktualisierung von Produktinformationen bis hin zur Verfolgung von Benutzeraktivitäten müssen Website-Betreiber häufig auf Datenbanktabellen zugreifen und Einträge bearbeiten. Das HNP Database Tool Plugin bietet eine benutzerfreundliche Lösung, um diese Aufgaben direkt aus dem WordPress-Dashboard heraus durchzuführen.

Was ist das Database Change Plugin?: Das HNP Database Plugin ist ein leistungsstarkes Tool, das es WordPress-Benutzern ermöglicht, Datenbankeinträge abzurufen und zu ändern, ohne dass sie sich direkt mit SQL-Abfragen befassen müssen. Mit diesem Plugin können Benutzer die gewünschten Tabellen und Spalten angeben, nach denen sie suchen möchten, und dann die Ergebnisse direkt im WordPress-Adminbereich anzeigen und bearbeiten.

Funktionen des Plugins:

Einfache Konfiguration: Das Plugin fügt eine benutzerdefinierte Optionenseite im WordPress-Dashboard hinzu, auf der Benutzer die Datenbanktabelle, die zu durchsuchende Spalte und optional eine weitere Spalte für die Anzeige auswählen können.
Sicherheit im Vordergrund: Das Plugin verwendet sichere Methoden zur Datenbereinigung und Escapen, um XSS-Angriffe und SQL-Injectionen zu verhindern und die Sicherheit der Website zu gewährleisten.
Live-Vorschau der Ergebnisse: Nach der Konfiguration zeigt das Plugin eine Live-Vorschau der Datenbankeinträge an, die den angegebenen Kriterien entsprechen. Benutzer können die Ergebnisse direkt im Adminbereich anzeigen und bearbeiten.
Direkte Aktualisierung: Das Plugin ermöglicht es Benutzern, Werte direkt aus der Ergebnistabelle heraus zu bearbeiten und zu aktualisieren, ohne die Seite verlassen zu müssen. Dies spart Zeit und verbessert die Benutzerfreundlichkeit.

Verwendung des Plugins:

Installieren und aktivieren Sie das Das HNP Database Tool Plugin über den WordPress-Plugin-Manager.
Gehen Sie zum neuen Menüpunkt “Das HNP Database Tool” im WordPress-Dashboard und konfigurieren Sie die gewünschten Optionen.
Sobald die Optionen festgelegt sind, zeigt das Plugin eine Live-Vorschau der Datenbankeinträge an, die den angegebenen Kriterien entsprechen.
Bearbeiten Sie die Werte direkt aus der Ergebnistabelle heraus und aktualisieren Sie sie bei Bedarf.

Mehr Informationen und Kaufmöglichkeit:
https://shop.homepage-nach-preis.de/produkt/hnp-wordpress-database-tool/

Der Beitrag HNP SQL-Database Tool für WordPress als Plugin erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Wie einflussreich sind Backlinks für eine Webseite?

Homepage-nach-Preis — Fri, 22 Mar 2024 00:46:40 +0000

Kunden Original Screenshot, nach Nutzung unseres Backlink-Services, aus der Google Search Console

Die Bedeutung von Backlinks für die Suchmaschinenoptimierung (SEO) kann kaum überschätzt werden. Untersuchungen und Studien haben gezeigt, dass Backlinks einen wesentlichen Einfluss auf das Ranking einer Website in den Suchergebnissen haben und darüber hinaus auch Traffic, Umsatz und Konversionsraten beeinflussen können. Eine detaillierte Analyse verschiedener Daten und Studien verdeutlicht diesen Zusammenhang eindrucksvoll.

Korrelation mit Rankings: Moz führte im Jahr 2019 eine umfangreiche Studie durch, bei der über 12.000 Keywords und mehr als 100.000 Websites analysiert wurden. Die Ergebnisse dieser Studie zeigten eine starke Korrelation zwischen der Anzahl der Backlinks und der Position einer Website in den Suchergebnissen. Websites, die in den Top 10 der Google-Suchergebnisse rankten, wiesen im Durchschnitt über 168% mehr Backlinks auf als solche außerhalb dieser Top-Positionen. Eine ähnliche Untersuchung von Ahrefs bestätigte diese Ergebnisse und ergänzte, dass Seiten in den Top 10 im Durchschnitt über 3,5-mal mehr Backlinks hatten als Seiten auf den Plätzen 4 bis 10.

Einfluss auf Traffic und Umsatz: Im Jahr 2020 untersuchte SEMrush den Zusammenhang zwischen Backlinks und dem Traffic von Websites. Die Ergebnisse zeigten, dass Websites in den Top 3 der Suchergebnisse im Durchschnitt über 3,5-mal mehr Backlinks hatten als Websites auf den Plätzen 4 bis 10. Eine detaillierte Analyse von Backlinko im Jahr 2021 ergab zudem einen starken Zusammenhang zwischen Backlinks und dem Umsatz von Websites. Demnach erzielten Websites mit einer höheren Anzahl von hochwertigen Backlinks im Durchschnitt einen um bis zu 45% höheren Umsatz als solche mit weniger Backlinks.

Lokale SEO und Konversionsraten: Im Jahr 2019 widmete sich BrightLocal der Untersuchung des Einflusses von Backlinks auf lokale Suchergebnisse. Die Studie ergab, dass lokale Unternehmen mit einer größeren Anzahl qualitativ hochwertiger Backlinks tendenziell besser in den lokalen Suchergebnissen abschnitten. Zusätzlich fand eine Analyse von Search Engine Journal im Jahr 2022 heraus, dass Websites mit einer höheren Anzahl von Backlinks auch tendenziell höhere Konversionsraten aufwiesen.

Diese umfassende Zusammenstellung von Daten und Studien verdeutlicht die entscheidende Rolle, die Backlinks für die SEO-Performance von Websites spielen. Sie sind nicht nur ein wichtiger Ranking-Faktor, sondern haben auch einen signifikanten Einfluss auf Traffic, Umsatz und Konversionsraten.

Der Beitrag Wie einflussreich sind Backlinks für eine Webseite? erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Neues HNP Lieferdatum & Lieferzeit WooCommerce Plugin

Homepage-nach-Preis — Tue, 16 Jan 2024 14:27:04 +0000

In der dynamischen Welt des E-Commerce ist es von entscheidender Bedeutung, den Kunden eine nahtlose und personalisierte Erfahrung zu bieten. Das HNP Lieferdatum & Lieferzeit WordPress & WooCommerce Plugin eröffnet neue Möglichkeiten für Online-Shops, insbesondere für Restaurants, Bäckereien, Speditionen und Dienstleistungsanbieter. Diese Erweiterung ermöglicht es Kunden, das Lieferdatum und die Lieferzeit flexibel zu wählen, um den individuellen Anforderungen gerecht zu werden.

Überblick der Funktionen:

Datums- und Zeitauswahl:
- Integriert mühelos neue Felder für Lieferdatum und Lieferzeit auf der WooCommerce-Kassenseite.
- Unabhängige und synchronisierte Nutzung von Datum- und Zeitauswahl-Plugins.
Datenverwaltung:
- Gespeicherte Informationen werden an die Admin- und Kunden-E-Mails der Kaufbestätigung weitergeleitet.
- Anzeige der Daten in der Admin-Bestellübersicht für eine einfache Verwaltung.
Validierung und Filteroptionen:
- Gültigkeitsprüfung der eingegebenen Daten für eine zuverlässige Erfassung.
- Datumsauswahl kann nach Wochentagen und individuellen Terminen gefiltert werden.
Maximale Uhrzeit und Verzögerungsoptionen:
- Einführung einer “maximalen Uhrzeit” Funktion für Lieferungen am Bestelltag.
- Möglichkeit der Lieferverzögerung in Tagen oder Minuten für individuelle Anforderungen.
Benutzerfreundliche Auswahlmöglichkeiten:
- Datumsauswahl durch HTML-Kalender und Uhrzeitauswahl durch Dropdown-Menüs.
- Anpassbare Auswahl für einen effizienten Bestellprozess.
Vielseitige Anwendungsmöglichkeiten:
- Optimal für Restaurants, Bäckereien, Speditionen und andere liefernde Shops.
- Ebenso geeignet für Dienstleistungsunternehmen, die Terminvereinbarungen anbieten.
Individuelle Konfiguration:
- Freie Wahl zwischen Datum- und/oder Zeitauswahl je nach den Bedürfnissen des Geschäfts.
- Flexible Anpassung an die spezifischen Anforderungen des Online-Shops.

Mehr Informationen und Kaufmöglichkeit:

https://shop.homepage-nach-preis.de/produkt/hnp-lieferdatum-lieferzeit-woocommerce-plugin/

Der Beitrag Neues HNP Lieferdatum & Lieferzeit WooCommerce Plugin erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.