php - Web Design | Creazione Siti Internet

Creare plugin WordPress con AI: metodo completo

Emilio Petrozzi — Tue, 02 Jun 2026 13:06:09 +0000

Creare un plugin WordPress con l'intelligenza artificiale non significa "chiedere a ChatGPT di scrivere un plugin". Significa progettare un flusso di lavoro in cui l'AI genera codice candidato, ma tu mantieni il controllo su requisiti, sicurezza, test e rilascio. In questa guida trovi un metodo in nove fasi, già usato per rilasciare plugin reali, con prompt operativi, snippet PHP pronti e una checklist di code review pensata per chi sviluppa in proprio e non vuole pubblicare codice bacato.

L'obiettivo è trasformare un prompt in un artefatto distribuibile, non un esercizio di stile. Vediamo come, passo dopo passo, integrando l'AI in un processo di ingegneria WordPress serio.

Perché serve un metodo, non solo un prompt

Scrivere "creami un plugin WordPress per gestire i preventivi" produce quasi sempre un file singolo, nessuna struttura di namespace, nessuna sanitizzazione, zero test. Il prompt è solo il punto di partenza: ciò che separa un plugin amatoriale da uno distribuibile è la pipeline.

Se hai già letto la nostra guida su come progettare, scrivere e ottimizzare un plugin WordPress con AI, sai che il vero vantaggio competitivo non è la velocità di generazione ma la capacità di ripetere il processo. Un metodo replicabile ti permette di passare da un'idea a un plugin pubblicato in una settimana, non in sei mesi. Lo stesso approccio si applica a temi WordPress complessi e a strumenti di sviluppo locale basati su Docker, dove la standardizzazione fa la differenza.

Le 9 fasi del metodo

Il flusso è sequenziale ma iterativo. Ogni fase produce un output concreto che alimenta la successiva.

Fase	Output	Strumento AI utile
1. Requisiti	User story + criteri di accettazione	LLM generico + brainstorming
2. Architettura	Schema classi, hook, tabelle DB	LLM con contesto WordPress
3. Prompt design	Prompt strutturato con vincoli	LLM con system prompt dedicato
4. Generazione	Codice PHP/JS/CSS candidato	Cursor, Copilot, Continue.dev
5. Code review	Lista vulnerabilità e refactoring	LLM come revisore + PHPStan
6. Sicurezza	Escape, nonce, capability check	LLM + plugin "Plugin Check"
7. Test	Unit test + smoke test WP-CLI	PHPUnit + WP-CLI scaffold
8. Refactoring	Versione pulita, documentata	LLM come pair programmer
9. Distribuzione	ZIP, repository, readme.txt	wp-svn, GitHub Releases

Le prime quattro fasi sono dove l'AI dà il massimo vantaggio. Le ultime cinque sono dove il tuo giudizio tecnico diventa insostituibile.

Fase 1: requisiti come user story

Parti sempre da cosa deve fare il plugin, non da come. Una user story ben scritta è: "Come amministratore del sito, voglio poter associare una data di scadenza a ogni post, per visualizzare un countdown nel frontend".

L'AI trasforma questa story in criteri di accettazione, edge case e vincoli non funzionali (performance, compatibilità PHP 8.2+, i18n). Meglio scriverli prima di generare codice: ti serviranno per i test.

Ecco un prompt efficace per la fase 1:

# esempio codice
Agisci come product manager WordPress. Per la user story "[INCOLLA QUI]" genera: 5 criteri di accettazione, 3 edge case, requisiti di compatibilità (versione WordPress minima, PHP minimo, ruoli utente coinvolti), e una lista di hook WordPress da usare. Rispondi in italiano, formato Markdown.

Il risultato diventa l'input della fase 2. Niente codice ancora, niente scelte tecniche premature.

Fase 2: architettura prima del codice

Chiedi all'AI uno schema di alto livello: classi, interfacce, tabelle custom, hook e filtri, file e cartelle. Questo passaggio ti permette di valutare se la struttura proposta ha senso prima di investire tempo nella generazione del codice.

# esempio codice
Dato il plugin "[NOME]" con questi requisiti: [INCOLLA CRITERI DI ACCETTAZIONE]. Proponi: struttura directory, elenco classi con responsabilità, tabelle DB custom (se necessarie), hook WordPress da implementare (action e filter), e dipendenze esterne. Non scrivere codice, solo architettura.

Conferma o modifica lo schema. Una volta validato, diventa il brief per la generazione.

Fase 3: prompt design con vincoli espliciti

Il prompt di generazione è il momento più delicato. Includi sempre: contesto WordPress (versioni supportate, hook da usare), standard di codifica (PSR-12, WordPress Coding Standards), requisiti di sicurezza (sanitize, escape, nonce, capability), e formato di output (un file per volta, con header di plugin completo).

Un prompt ben strutturato produce codice quasi pronto. Uno vago produce spazzatura. Non lesinare sui dettagli.

Fase 4: generazione del codice candidato

Usa l'editor AI (Cursor, Continue.dev, GitHub Copilot) per generare il codice file per file. Chiedi esplicitamente commenti PHPDoc, gestione degli errori e un blocco register_activation_hook per il setup iniziale. La regola d'oro: genera, leggi, correggi, integra. Non accettare mai il primo output senza averlo capito.

Esempio di header plugin generato correttamente:





Nota la riga ABSPATH: senza quella, chiunque può includere il file via URL e bypassare i controlli. È un dettaglio che l'AI spesso dimentica.



Fase 5: code review con PHPStan e AI



Passa il codice generato a PHPStan con il livello 5 o superiore. Poi chiedi all'AI di fare una review incrociata: "Trova bug logici, race condition, memory leak, gestione errori mancante". L'AI è sorprendentemente brava a trovare quello che tu, abbagliato dal codice appena scritto, non vedi.



Un comando utile per la review AI:



# analisi statica PHPStan sul plugin
vendor/bin/phpstan analyse --level=6 includes/ src/



Output tipico: errori di tipo mancanti, parametri non validati, return type inconsistenti. Tutto risolvibile prima ancora di aprire il browser.



Fase 6: checklist di sicurezza WordPress



WordPress ha un modello di sicurezza preciso. L'AI spesso lo ignora o lo applica in modo parziale. Ecco la checklist minima non negoziabile:



Ogni form ha un wp_nonce_field e verifica wp_verify_nonce lato server.
Ogni input utente passa per sanitize_text_field, absint, wp_kses_post o equivalente.
Ogni output passa per esc_html, esc_attr, esc_url o wp_kses_post.
Ogni capability check usa current_user_can( 'manage_options' ) (o capability più specifica).
Le query SQL usano $wpdb->prepare() con placeholder %s, %d, %f.
I file letti/scritti usano WP_Filesystem API, non file_get_contents diretto.



Se uno di questi punti manca, il plugin non è pronto per la distribuzione. Nessuna scusa, nessuna "lo aggiungo dopo".



Fase 7: test con PHPUnit e WP-CLI



Il modo più rapido per testare un plugin è usare wp-cli scaffold plugin-tests. Crea una struttura di test standard con PHPUnit e WP-CLI, inclusi test di integrazione. Scrivi test per ogni criterio di accettazione della fase 1. Se un criterio non ha un test, non è un criterio.



# installa WP-CLI test scaffold nel plugin
wp scaffold plugin-tests mio-plugin



L'output è una cartella tests/ con file di esempio, configurazione PHPUnit e script per lanciare la suite. Da lì in poi scrivi test reali: un test per ogni metodo pubblico della classe principale, un test per ogni hook registrato.



Fase 8: refactoring finale



Dopo i test, chiedi all'AI un refactoring mirato: estrai metodi lunghi, rinomina variabili, aggiungi type hint mancanti, sostituisci array() con [], converte stringhe in costanti di classe se usate più volte. Il refactoring post-test è il momento in cui il codice diventa manutenibile. Non farlo prima dei test: senza test, il refactoring è un terno al lotto.



Un prompt utile per questa fase:



# esempio codice
Refactoring del file [NOME FILE]. Obiettivi: type hint completi, metodi sotto le 30 righe, naming coerente, nessuna duplicazione. Mantieni la logica invariata. Restituisci solo il codice finale con commenti PHPDoc.



Fase 9: distribuzione e manutenzione



Una volta che il plugin è solido, crea lo ZIP e pubblicalo su wordpress.org tramite wp-svn, oppure su GitHub con una release. Il file readme.txt segue il formato standard WordPress: header con metadata, sezione "Description", "Installation", "Frequently Asked Questions", "Changelog", "Upgrade Notice". L'AI può generare un primo draft, ma ricontrolla: wordpress.org rifiuta readme con link a siti di terze parti non autorizzati, con tag non standard, con sezioni mancanti.



# crea zip distribuzione plugin
wp dist-archive /percorso/del/plugin mio-plugin-1.0.0



Dopo la pubblicazione, il lavoro non è finito: monitora il forum di supporto, rispondi ai bug report, rilascia patch. Un plugin senza manutenzione è un plugin che smette di funzionare al primo aggiornamento major di WordPress.



Errori comuni da evitare



Anche con un buon metodo, alcuni errori sono ricorrenti. Ecco i più frequenti osservati su plugin AI-generati pubblicati su wordpress.org e repository privati.




Errore Conseguenza Come evitarlo
Plugin monolitico da 2000 righe in un solo file Impossibile manutenere, test, debuggare Forza struttura a cartelle nella fase 3
Nessuna traduzione (text domain) Plugin rifiutato da wordpress.org Aggiungi __(), _e(), esc_html__() ovunque
Query dirette senza prepare SQL injection, rifiuto plugin check Standardizza uso di $wpdb->prepare()
Asset (JS/CSS) caricati ovunque Page bloat, conflitti con altri plugin Usa wp_enqueue_script condizionato
Nessuna deactivation/uninstall hook Dati orfani nel database Aggiungi register_uninstall_hook con cleanup




La tabella è un riassunto operativo. L'errore più subdolo è il primo: un file da 2000 righe è facile da generare con l'AI, impossibile da mantenere senza refactoring radicale.



Workflow integrato: dall'idea al repository



Mettiamo insieme le nove fasi in un flusso settimanale realistico. Giorno 1-2: requisiti e architettura, con sessioni AI di 2-3 ore. Giorno 3-4: generazione e code review, con l'AI come pair programmer. Giorno 5: test e refactoring, senza AI generativa ma con PHPStan e PHPUnit. Giorno 6: readme, asset, documentazione. Giorno 7: pubblicazione e annuncio.



Questo ritmo è compatibile con un singolo sviluppatore che lavora part-time. Con un team di due persone (uno sviluppatore, uno reviewer) si scende a 3-4 giorni. Il collo di bottiglia non è mai la generazione del codice: è la review e i test.



Quando l'AI non basta



Ci sono ambiti dove l'intelligenza artificiale generativa non è ancora affidabile come unico input:



Logica di business complessa con regole fiscali o legali: serve dominio umano per validare i requisiti.
Integrazione con API di pagamento (Stripe, PayPal): troppe edge case, troppe versioni API, troppe conseguenze economiche di un bug.
Plugin che gestiscono dati sanitari o personali sensibili: la conformità GDPR richiede revisione legale, non solo tecnica.



In questi casi l'AI è utile per generare il codice candidato, ma serve un dominio umano per validare. Non affidarti mai al 100% all'output AI per aree critiche.



Strumenti consigliati per il workflow



Ecco la mia toolchain attuale, testata su plugin reali pubblicati nel 2025-2026:



Editor AI: Cursor per la generazione, Continue.dev come alternativa open source, entrambi con supporto a modelli locali (privacy).
Analisi statica: PHPStan livello 6+ con regole WordPress custom, Psalm come alternativa.
Test: PHPUnit + WP-CLI scaffold plugin-tests, Brain Monkey per mock delle funzioni WordPress.
Sicurezza: Plugin "Plugin Check" di wordpress.org per validare submission, PHP_CodeSniffer con WordPress Coding Standards.
Versionamento: Git con conventional commits, GitHub Actions per CI, wp-env per ambienti di sviluppo riproducibili.



Nessuno di questi strumenti è obbligatorio, ma l'insieme copre le fasi 4-9 con automazione. Il tempo risparmiato in setup si ripaga dal primo plugin in poi.



Riferimenti ufficiali e risorse esterne



Per approfondire i temi toccati in questa guida, queste sono le fonti primarie che uso quotidianamente:



Plugin Handbook ufficiale di WordPress.org — documentazione canonica su hook, API, sicurezza, internazionalizzazione. È la bibbia: ogni dubbio su un filtro o un action hook si risolve qui.
WordPress Coding Standards su GitHub — le regole di stile PHP/JS/CSS che ogni plugin su wordpress.org deve rispettare, installabili come standard PHPCS.
Make WordPress Core — discussione su PHP 8.x e WordPress 7.0 — le release notes ufficiali, le proposte di deprecazione, gli aggiornamenti sui requisiti minimi di PHP che impattano direttamente i plugin moderni.
Plugin Check su wordpress.org — strumento di validazione pre-submission che verifica automaticamente decine di requisiti tecnici e di sicurezza.
WP-CLI command reference — ogni comando disponibile, con flag ed esempi, utile per automatizzare test, scaffolding e distribuzione.
Common APIs — Settings, Options, Transients — pattern consolidati per memorizzare configurazioni, con confronto tra opzioni e transients.



Le fonti terze (blog, tutorial YouTube) sono ottime per imparare pattern, ma quando decidi un'architettura o una regola di sicurezza, il riferimento finale deve sempre essere la documentazione ufficiale. Le AI a volte propongono pattern obsoleti (hook deprecati, funzioni rimosse in versioni recenti): solo leggendo le release notes aggiornate te ne accorgi.



Caso studio: 7 giorni per un plugin reale



Per chiudere con un esempio concreto, ecco come ho applicato il metodo a un plugin reale: un sistema di scadenza post con countdown nel frontend. Il plugin è in produzione su tre siti, tutti aggiornati a WordPress 6.5+ senza conflitti.



Giorno 1: requisiti



Una mattina con sessione AI di 2 ore, partendo dalla user story "voglio una data di scadenza visibile sul post con countdown automatico". Output: 6 criteri di accettazione, 4 edge case (post programmati, post privati, timezone del sito, caching del countdown), decisione di usare un meta box classico per compatibilità con i page builder più diffusi. Tutto scritto in un file requirements.md versionato su Git.



Giorno 2: architettura



Sessione AI con prompt di architettura: output una struttura a tre classi (Main, MetaBox, Frontend), un custom post meta mio_plugin_expiry_date, due hook (uno in admin per il meta box, uno in frontend per il rendering), zero tabelle custom. Ho aggiunto un requirements.md con la sezione "Decisioni di architettura" per spiegare perché niente tabelle custom: i meta post bastano per il caso d'uso, le tabelle custom aggiungono complessità di migrazione e manutenzione non giustificata.



Giorno 3-4: generazione e review



Ho generato il codice file per file in Cursor, con prompt che includevano sempre i requisiti di sicurezza (nonce, sanitize, esc) e i criteri di accettazione come checklist inline. Poi PHPStan livello 6 ha trovato 4 errori di tipo (parametri nullable non gestiti) che ho corretto in 20 minuti. Una seconda passata AI per code review ha pescato 2 bug logici (confronto tra DateTime e stringa in un caso edge).



Giorno 5: test



wp scaffold plugin-tests ha creato la struttura PHPUnit. Ho scritto 8 test, uno per criterio di accettazione. Due test hanno rivelato un bug nella gestione del timezone (il countdown mostrava un'ora di differenza tra backend e frontend in siti con timezone Europe/Rome). Bug risolto passando sempre per wp_date() invece di date() nativo PHP.



Giorno 6: documentazione



Readme.txt, screenshot, changelog iniziale, documentazione del meta box. L'AI ha generato il primo draft, io ho ricontrollato formattazione wordpress.org, licenza, sezioni mancanti.



Giorno 7: pubblicazione



ZIP, invio a wordpress.org, attesa di approvazione (3 giorni per la review). Tempo totale: 7 giorni di lavoro effettivo, di cui circa 2 ore al giorno. Il resto del tempo era sessioni AI, code review, test. Il plugin è ancora attivo, riceve aggiornamenti di compatibilità a ogni release major di WordPress.



Questo caso studio dimostra che il metodo è realistico anche per sviluppatori soli, a patto di non saltare le fasi 5-7 (review, sicurezza, test) per la pressione di rilasciare prima.



Domande frequenti



L'AI può sostituire uno sviluppatore WordPress? No. L'AI accelera la scrittura del codice ma non sostituisce la capacità di progettare architetture, fare scelte tecniche e manutenere nel tempo. Un plugin scritto solo con prompt è un plugin fragile.



Quale modello AI è migliore per PHP WordPress? I modelli addestrati su codice recente (Claude 3.5+, GPT-4o, Gemini 2.5) performano bene su pattern WordPress comuni. Per hook meno documentati, meglio includere esempi di documentazione ufficiale nel prompt.



È legale vendere plugin scritti con AI? Sì, purché il codice sia tuo (o rilasciato con licenza compatibile GPL) e tu possa mantenerlo. La licenza del plugin deve essere GPL v2 o compatibile, come richiesto da wordpress.org per i plugin gratuiti.



Come gestisco la qualità del codice AI su larga scala? Con un sistema di review obbligatorio: PHPStan in CI, code review umana, test automatici su ogni PR. Il codice generato entra in produzione solo dopo gli stessi gate del codice scritto a mano.



Conclusione



Creare plugin WordPress con AI è un vantaggio competitivo reale se lo fai con metodo, non con magia. Le nove fasi descritte qui (requisiti, architettura, prompt, generazione, review, sicurezza, test, refactoring, distribuzione) trasformano l'AI da "trucco per prototipi" a strumento professionale. Parti sempre dai requisiti, mai dal codice. Testa sempre, anche il codice "semplice". E ricorda: il prompt è l'inizio, non la fine.



Se vuoi approfondire il tema dei confronti tra coding assistant AI o le strategie per vendere plugin su WooCommerce, trovi guide dedicate sul blog. Il metodo è trasversale: vale per plugin, temi, integrazioni custom e prodotti SaaS costruiti su WordPress.

Errore	Conseguenza	Come evitarlo
Plugin monolitico da 2000 righe in un solo file	Impossibile manutenere, test, debuggare	Forza struttura a cartelle nella fase 3
Nessuna traduzione (text domain)	Plugin rifiutato da wordpress.org	Aggiungi `__()`, `_e()`, `esc_html__()` ovunque
Query dirette senza prepare	SQL injection, rifiuto plugin check	Standardizza uso di `$wpdb->prepare()`
Asset (JS/CSS) caricati ovunque	Page bloat, conflitti con altri plugin	Usa `wp_enqueue_script` condizionato
Nessuna deactivation/uninstall hook	Dati orfani nel database	Aggiungi `register_uninstall_hook` con cleanup



Container Docker per PHP: setup minimale per sviluppare in locale
Emilio Petrozzi — Fri, 22 May 2026 12:39:18 +0000
Docker ha cambiato il modo in cui sviluppiamo applicazioni PHP. Non devi più installare PHP, MySQL, Nginx o Apache direttamente sulla tua macchina: un container gestisce tutto, e puoi distruggere e ricreare l'ambiente senza lasciare tracce.


In questa guida ti mostro un setup minimale, funzionante e replicabile per sviluppare qualsiasi progetto PHP in locale, dal classico WordPress a un'applicazione Laravel moderna.


Perché Docker e non XAMPP o MAMP?


XAMPP e MAMP vanno bene per iniziare, ma hanno limiti precisi:



Conflitti di versione — PHP 7.4 sulla macchina, il server di produzione usa 8.2, e il bug si vede solo in produzione
Servizi diversi — Il tuo portatile ha MySQL, il server di produzione usa MariaDB o PostgreSQL
Niente isolamento — Se rompi qualcosa, rischi di rompere tutto il sistema



Docker risolve tutto questo: ogni progetto ha il suo ambiente, con le versioni esatte che servono, e puoi condividerlo con il team senza che nessuno debba installare niente di specifico sulla propria macchina.


Il file docker-compose.yml minimale


La configurazione base per un progetto PHP con database MySQL e server web Nginx richiede tre servizi: php, mysql e nginx.


# docker-compose.yml versione minima funzionante
version: '3.8'

services:
  app:
    image: php:8.2-fpm
    volumes:
      - ./app:/var/www/html
    depends_on:
      - db

  web:
    image: nginx:alpine
    ports:
      - '8080:80'
    volumes:
      - ./app:/var/www/html
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - app

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: app
      MYSQL_USER: developer
      MYSQL_PASSWORD: devpass
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:


Questo file definisce tre container che comunicano su una rete Docker interna. La porta 8080 sulla tua macchina viene instradata alla porta 80 del container Nginx.


La configurazione Nginx


Il container Nginx ha bisogno di un file di configurazione per sapere come parlare con PHP-FPM:


# nginx.conf
server {
    listen 80;
    index index.php index.html;
    root /var/www/html;

    location / {
        try_files  / /index.php?;
    }

    location ~ \.php$ {
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME ;
        include fastcgi_params;
    }
}


Il parametro fastcgi_pass app:9000 dice a Nginx di inviare i file PHP al container app sulla porta 9000, che è la porta standard di PHP-FPM.


Primo avvio e verifica


Crea la struttura delle cartelle e il file index.php di test:


# Crea la struttura delle cartelle
mkdir -p app nginx

# Crea il file index.php di test
echo ' app/index.php


Ora avvia i container:


# Avvia tutti i servizi in background
docker-compose up -d

# Verifica che tutti i container siano attivi
docker-compose ps


Apri il browser e vai su http://localhost:8080. Se tutto funziona, vedrai la pagina phpinfo() con la configurazione di PHP 8.2.


Installare le estensioni PHP necessarie


L'immagine ufficiale php:8.2-fpm è minimale. Per WordPress o Laravel servono alcune estensioni. Puoi estendere l'immagine con un Dockerfile:


# Dockerfile
FROM php:8.2-fpm

# Installa le estensioni necessarie
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd


Modifica il docker-compose.yml per usare il Dockerfile invece dell'immagine:


# Nel docker-compose.yml, sostituisci la riga:
#     image: php:8.2-fpm
# Con:
    build:
      context: .
      dockerfile: Dockerfile


Gestire i permessi file


Su Linux e macOS non avrai problemi di permessi. Su Windows con WSL2, potresti trovarti con file creati da root dentro i container. Per evitarlo:


# Imposta l'utente che matchi il tuo UID locale
services:
  app:
    user: '1003:1000'
    # ... resto della config


Oppure, più semplicemente, usa un file .env:


# .env
UID=1003
GID=1003


Accesso al database da fuori Docker


Per collegare un client MySQL esterno (come TablePlus o DBeaver) al container:


# Aggiungi al servizio db nel docker-compose.yml:
  db:
    image: mysql:8.0
    ports:
      - '3306:3306'
    # ... resto della config


Ora puoi collegarti a localhost:3306 con le credenziali definite nel file MYSQL_*.


Comandi essenziali da ricordare





Comando
Funzione




docker-compose up -d
Avvia tutti i servizi in background


docker-compose down
Ferma e rimuove i container


docker-compose down -v
Ferma e rimuove anche i volumi (cancella il DB)


docker-compose exec app bash
Apre una shell dentro il container PHP


docker-compose logs -f
Mostra i log di tutti i container in tempo reale


docker-compose restart
Riavvia tutti i servizi





WordPress in Docker: la versione completa


Per WordPress il discorso si allunga, perché servono volumi persistenti per wp-content, un container per Redis (utile per la cache), e la gestione dei certificati HTTPS in sviluppo. Il risultato è un setup del genere:


# Versione WordPress completa
services:
  wordpress:
    image: wordpress:6.4-php8.2
    volumes:
      - wordpress_data:/var/www/html
      - ./uploads.ini:/usr/local/etc/php/conf.d/uploads.ini
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    depends_on:
      - db
      - redis

  redis:
    image: redis:7-alpine
    command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru

  db:
    image: mysql:8.0
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress

volumes:
  wordpress_data:
  db_data:


Conclusione


Docker non è magia: è un modo strutturato di dichiarare il tuo ambiente. Una volta che hai un docker-compose.yml funzionante, puoi distruggere tutto, ricrearlo su un'altra macchina, condividerlo con il team, e siete tutti sulla stessa configurazione. È il minimalismo che scale.


I prossimi passi:



Prova ad aggiungere PHPMyAdmin come container
Configura MailHog per intercettare le email in sviluppo
Integra Blackfire o Tideways per il profiling



FAQ


Docker consuma molte risorse?


WooCommerce Plugin Development 2026: Aumenta le Vendite del 40% con Codice Custom
Emilio Petrozzi — Thu, 09 Apr 2026 22:15:08 +0000
WooCommerce Plugin Development: Come Aumentare le Vendite del 40% con Codice Custom
Tempo di lettura: 12 minuti
Se gestisci uno store WooCommerce o sviluppi per clienti e-commerce, sai che la differenza tra un sito che converte e uno che stenta sta spesso nei dettagli. I plugin del marketplace offrono funzionalità generiche, ma quando serve qualcosa di specifico per il tuo business, il codice custom fa la differenza.
In questa guida ti mostrerò come sviluppare plugin WooCommerce personalizzati che possono aumentare le conversioni fino al 40%, con esempi di codice pronto all'uso che puoi implementare oggi stesso.
Perché Sviluppare Plugin Custom per WooCommerce
Il marketplace WooCommerce conta oltre 6.000 estensioni, ma c'è un problema: sono pensati per il mercato di massa. Quando hai bisogno di:

Integrazioni con sistemi proprietari italiani (fatturazione, corrieri locali)
Logiche di pricing complesse (sconti per regione, B2B tier)
Checkout personalizzati per il tuo settore
Automazioni specifiche per il tuo flusso di lavoro

...il codice custom diventa non solo conveniente, ma necessario.
I numeri parlano chiaro:

Gli store con checkout personalizzati vedono un +35% di completamento ordini
I sistemi di upsell intelligenti aumentano l'AOV (Average Order Value) del 20-40%
Le notifiche personalizzate riducono i carrelli abbandonati del 15-25%


Esempio 1: Upsell Intelligente nel Carrello
Uno dei modi più efficaci per aumentare il valore medio dell'ordine è suggerire prodotti complementari nel carrello. Ecco un plugin che lo fa automaticamente:
cart;
        if ($cart->is_empty()) {
            return [];
        }

        // Raccogli categorie dal carrello
        $categories = [];
        foreach ($cart->get_cart() as $item) {
            $product_cats = wp_get_post_terms(
                $item['product_id'], 
                'product_cat', 
                ['fields' => 'ids']
            );
            $categories = array_merge($categories, $product_cats);
        }

        // Trova prodotti nelle stesse categorie, non nel carrello
        $cart_ids = array_column($cart->get_cart(), 'product_id');

        $args = [
            'post_type' => 'product',
            'posts_per_page' => 3,
            'post__not_in' => $cart_ids,
            'tax_query' => [
                [
                    'taxonomy' => 'product_cat',
                    'field' => 'term_id',
                    'terms' => array_unique($categories),
                ]
            ],
            'meta_query' => [
                [
                    'key' => '_stock_status',
                    'value' => 'instock'
                ]
            ],
            'orderby' => 'rand'
        ];

        return wc_get_products($args);
    }

    /**
     * Mostra i prodotti upsell nel carrello
     */
    public function show_upsell_products() {
        $upsells = $this->get_upsell_products();

        if (empty($upsells)) {
            return;
        }

        echo '';
        echo '' . __('Potrebbe interessarti anche...', 'smart-upsell') . '';
        echo '';

        foreach ($upsells as $product) {
            $price = $product->get_price_html();
            $image = $product->get_image('thumbnail');
            $link = $product->get_permalink();

            echo '';
            echo '';
            echo $image;
            echo '' . esc_html($product->get_name()) . '';
            echo '' . $price . '';
            echo '';
            echo '';
        }

        echo '';
    }

    /**
     * Carica gli stili CSS
     */
    public function enqueue_styles() {
        if (is_cart()) {
            wp_add_inline_style('woocommerce-general', '
                .cart-upsell {
                    background: #f7f7f7;
                    padding: 20px;
                    border-radius: 8px;
                    margin-top: 20px;
                }
                .cart-upsell h3 {
                    margin-bottom: 15px;
                    color: #333;
                }
                .upsell-products {
                    display: grid;
                    grid-template-columns: repeat(3, 1fr);
                    gap: 15px;
                    list-style: none;
                    padding: 0;
                    margin: 0;
                }
                .upsell-item img {
                    width: 100%;
                    height: auto;
                    border-radius: 4px;
                }
                .upsell-title {
                    display: block;
                    font-weight: 600;
                    margin-top: 8px;
                    color: #333;
                }
                .upsell-price {
                    display: block;
                    color: #0073aa;
                    font-weight: 700;
                }
                @media (max-width: 768px) {
                    .upsell-products {
                        grid-template-columns: 1fr;
                    }
                }
            ');
        }
    }
}

new Smart_Cart_Upsell();
Come Funziona

Analizza le categorie dei prodotti nel carrello
Cerca prodotti correlati non ancora nel carrello
Mostra 3 suggerimenti con immagine, nome e prezzo
Design responsive per mobile

Risultato atteso: +15-25% AOV (Average Order Value)

Esempio 2: Notifiche Stock Personalizzate
Le notifiche "torna in stock" native di WooCommerce sono limitate. Questo plugin aggiunge notifiche automatiche con email personalizzate e SMS opzionali:
is_in_stock()) {
            return;
        }

        wp_nonce_field('asn_subscribe', 'asn_nonce');
        ?>
        
            
                
            
            

            
                
                
                
                
            

            
        

        

        
         $email,
            'phone' => $phone,
            'date' => current_time('mysql')
        ];

        // Evita duplicati
        $exists = array_filter($waitlist, function($item) use ($email) {
            return $item['email'] === $email;
        });

        if (empty($exists)) {
            $waitlist[] = $subscription;
            update_post_meta($product_id, '_asn_waitlist', $waitlist);
            wp_send_json_success(__('Ti avviseremo quando il prodotto sarà disponibile!', 'asn'));
        } else {
            wp_send_json_error(__('Sei già iscritto a questa lista', 'asn'));
        }
    }

    /**
     * Notifica gli iscritti quando il prodotto torna in stock
     */
    public function notify_waitlist($product_id, $stock_status) {
        if ($stock_status !== 'instock') {
            return;
        }

        $waitlist = get_post_meta($product_id, '_asn_waitlist', true);

        if (empty($waitlist)) {
            return;
        }

        $product = wc_get_product($product_id);
        $product_name = $product->get_name();
        $product_link = $product->get_permalink();

        $settings = get_option($this->option_name);
        $email_template = $settings['email_template'] ?? 'default';

        foreach ($waitlist as $subscription) {
            $this->send_notification(
                $subscription['email'],
                $subscription['phone'],
                $product_name,
                $product_link,
                $email_template
            );
        }

        // Pulisci la waitlist dopo l'invio
        delete_post_meta($product_id, '_asn_waitlist');
    }

    /**
     * Invia notifica email/SMS
     */
    private function send_notification($email, $phone, $product_name, $product_link, $template) {
        $subject = sprintf(__('Torna in stock: %s', 'asn'), $product_name);

        $message = sprintf(
            __("Ciao!\n\nIl prodotto %s è tornato disponibile!\n\nAcquistalo ora: %s\n\nNon aspettare, le scorte sono limitate.", 'asn'),
            $product_name,
            $product_link
        );

        // Email
        wp_mail($email, $subject, $message);

        // SMS (se configurato e numero presente)
        if ($phone && class_exists('WC_SMS')) {
            // Integrazione con gateway SMS
            do_action('asn_send_sms', $phone, $subject);
        }
    }

    /**
     * Aggiungi menu admin
     */
    public function add_admin_menu() {
        add_submenu_page(
            'woocommerce',
            __('Notifiche Stock', 'asn'),
            __('Notifiche Stock', 'asn'),
            'manage_woocommerce',
            'advanced-stock-notifications',
            [$this, 'admin_page']
        );
    }

    /**
     * Pagina admin
     */
    public function admin_page() {
        ?>
        
            
            
                option_name);
                do_settings_sections('advanced-stock-notifications');
                submit_button();
                ?>
            

            
            show_waitlist_stats(); ?>
        
         'product',
            'meta_key' => '_asn_waitlist',
            'posts_per_page' => 20
        ];

        $products = get_posts($args);

        if (empty($products)) {
            echo '' . __('Nessuna waitlist attiva', 'asn') . '';
            return;
        }

        echo '';
        echo '';

        foreach ($products as $post) {
            $waitlist = get_post_meta($post->ID, '_asn_waitlist', true);
            $count = count($waitlist);
            $last = end($waitlist);

            echo '';
            echo '';
            echo '';
            echo '';
            echo '';
        }

        echo 'Prodotto Iscritti Ultima iscrizione
' . esc_html($post->post_title) . ' ' . $count . ' ' . esc_html($last['date'] ?? '-') . '';
    }

    /**
     * Registra impostazioni
     */
    public function register_settings() {
        register_setting($this->option_name, $this->option_name);

        add_settings_section(
            'asn_main',
            __('Configurazione', 'asn'),
            null,
            'advanced-stock-notifications'
        );

        add_settings_field(
            'email_template',
            __('Template Email', 'asn'),
            [$this, 'render_email_template_field'],
            'advanced-stock-notifications',
            'asn_main'
        );
    }

    public function render_email_template_field() {
        $settings = get_option($this->option_name);
        $value = $settings['email_template'] ?? 'default';
        ?>
        
        

Funzionalità Chiave

Form AJAX senza refresh pagina
Iscrizione con email + telefono opzionale
Notifica automatica al ritorno in stock
Dashboard admin con statistiche
Template email personalizzabili

Risultato atteso: Recupero del 15-25% di vendite perse per out of stock

Esempio 3: Checkout Field Optimizer
Un checkout troppo lungo è il nemico delle conversioni. Questo plugin ottimizza i campi in base al tipo di cliente:
 10,
            'billing_last_name' => 20,
            'billing_email' => 30,
            'billing_phone' => 40,
            'billing_country' => 50,
            'billing_address_1' => 60,
            'billing_city' => 70,
            'billing_postcode' => 80,
        ];

        foreach ($priority as $field => $p) {
            if (isset($fields['billing'][$field])) {
                $fields['billing'][$field]['priority'] = $p;
            }
        }

        // Placeholder più chiari
        $fields['billing']['billing_phone']['placeholder'] = '+39 xxx xxx xxxx';
        $fields['billing']['billing_postcode']['placeholder'] = 'CAP';

        // Auto-focus sul primo campo
        add_action('woocommerce_before_checkout_form', function() {
            echo '';
        });

        return $fields;
    }

    /**
     * Campo note condizionale
     */
    public function conditional_notes_field() {
        $cart = WC()->cart;

        // Mostra campo note solo per ordini > €100 o con prodotti specifici
        $show_notes = false;

        if ($cart->subtotal > 100) {
            $show_notes = true;
        }

        // Oppure se ci sono prodotti che richiedono personalizzazione
        foreach ($cart->get_cart() as $item) {
            if (get_post_meta($item['product_id'], '_requires_notes', true)) {
                $show_notes = true;
                break;
            }
        }

        if ($show_notes) {
            woocommerce_form_field('order_special_notes', [
                'type' => 'textarea',
                'class' => ['form-row-wide'],
                'label' => __('Note aggiuntive per il tuo ordine', 'cfo'),
                'placeholder' => __('Es: regalo, consegna in orario specifico...', 'cfo'),
            ]);
        }
    }

    /**
     * Validazione smart
     */
    public function smart_validation() {
        $settings = get_option('cfo_settings', []);

        // Validazione CAP italiano
        if (!empty($_POST['billing_country']) && $_POST['billing_country'] === 'IT') {
            $cap = sanitize_text_field($_POST['billing_postcode'] ?? '');

            if (!preg_match('/^\d{5}$/', $cap)) {
                wc_add_notice(__('Inserisci un CAP italiano valido (5 cifre)', 'cfo'), 'error');
            }
        }

        // Validazione telefono italiano
        if (!empty($settings['validate_phone']) && !empty($_POST['billing_phone'])) {
            $phone = sanitize_text_field($_POST['billing_phone']);

            if (!preg_match('/^(\+39)?\s?\d{3}\s?\d{3}\s?\d{4}$/', $phone)) {
                wc_add_notice(__('Formato telefono non valido. Usa: +39 xxx xxx xxxx', 'cfo'), 'error');
            }
        }
    }

    /**
     * Campi B2B
     */
    public function b2b_fields($fields) {
        // Se l'utente ha un ruolo B2B
        if (current_user_can('customer_b2b')) {
            // Partita IVA obbligatoria
            $fields['billing_vat'] = [
                'label' => __('Partita IVA', 'cfo'),
                'required' => true,
                'class' => ['form-row-wide'],
                'priority' => 90,
            ];

            // Codice SDI
            $fields['billing_sdi'] = [
                'label' => __('Codice SDI', 'cfo'),
                'required' => false,
                'class' => ['form-row-wide'],
                'priority' => 95,
                'description' => __('Codice destinatario per fatturazione elettronica', 'cfo'),
            ];

            // PEC
            $fields['billing_pec'] = [
                'label' => __('PEC', 'cfo'),
                'required' => false,
                'class' => ['form-row-wide'],
                'priority' => 100,
            ];
        }

        return $fields;
    }

    /**
     * Salva meta dati ordine
     */
    public function save_order_meta($order_id) {
        if (!empty($_POST['order_special_notes'])) {
            update_post_meta(
                $order_id, 
                '_special_notes', 
                sanitize_textarea_field($_POST['order_special_notes'])
            );
        }

        if (!empty($_POST['billing_vat'])) {
            update_post_meta(
                $order_id, 
                '_billing_vat', 
                sanitize_text_field($_POST['billing_vat'])
            );
        }

        if (!empty($_POST['billing_sdi'])) {
            update_post_meta(
                $order_id, 
                '_billing_sdi', 
                sanitize_text_field($_POST['billing_sdi'])
            );
        }
    }

    /**
     * Aggiungi impostazioni admin
     */
    public function add_settings() {
        add_submenu_page(
            'woocommerce',
            __('Ottimizzazione Checkout', 'cfo'),
            __('Ottimizzazione Checkout', 'cfo'),
            'manage_woocommerce',
            'checkout-field-optimizer',
            [$this, 'settings_page']
        );
    }

    /**
     * Pagina impostazioni
     */
    public function settings_page() {
        if (isset($_POST['cfo_save'])) {
            check_admin_referer('cfo_settings');
            update_option('cfo_settings', [
                'remove_fields' => $_POST['remove_fields'] ?? [],
                'simplify_guest' => !empty($_POST['simplify_guest']),
                'validate_phone' => !empty($_POST['validate_phone']),
            ]);
            echo 'Impostazioni salvate!';
        }

        $settings = get_option('cfo_settings', []);
        ?>
        
            

            
                

                
                    
                        
                        
                            
                                >
                                
                            

                            
                                >
                                
                            

                            
                                >
                                
                            
                        
                    
                    
                        
                        
                            
                                >
                                
                            
                        
                    
                    
                        
                        
                            
                                >
                                
                            
                        
                    
                

                
                    
                
            

            
            show_checkout_stats(); ?>
        
        get_row("
            SELECT 
                COUNT(*) as total_orders,
                AVG(meta_value) as avg_checkout_time
            FROM {$wpdb->posts} p
            LEFT JOIN {$wpdb->postmeta} pm ON p.ID = pm.post_id
            WHERE p.post_type = 'shop_order'
            AND p.post_status IN ('wc-completed', 'wc-processing')
            AND pm.meta_key = '_checkout_duration'
        ");

        echo '';
        echo 'Ordini completati: ' . number_format($stats->total_orders) . '';
        if ($stats->avg_checkout_time) {
            echo 'Tempo medio checkout: ' . round($stats->avg_checkout_time) . ' secondi';
        }
        echo '';
    }
}

new Checkout_Field_Optimizer();
Benefici

Riduzione campi del 30-50% per guest
Validazione intelligente per clienti italiani
Campi B2B automatici (P.IVA, SDI, PEC)
Dashboard con statistiche

Risultato atteso: +20-35% tasso di completamento checkout

Esempio 4: Dynamic Pricing Engine
Il pricing dinamico può aumentare significativamente i margini. Ecco un motore di regole flessibile:
rules = get_option('dpe_rules', []);
    }

    /**
     * Applica pricing dinamico
     */
    public function apply_pricing($price, $product) {
        if (is_admin() || !is_numeric($price)) {
            return $price;
        }

        $original_price = (float) $price;
        $new_price = $original_price;

        foreach ($this->rules as $rule) {
            if (!$rule['active']) {
                continue;
            }

            if ($this->rule_applies($rule, $product)) {
                $new_price = $this->calculate_price($new_price, $rule, $product);
            }
        }

        return $new_price < $original_price ? $new_price : $price;
    }

    /**
     * Verifica se la regola si applica
     */
    private function rule_applies($rule, $product) {
        // Verifica data
        $now = current_time('timestamp');

        if (!empty($rule['start_date']) && strtotime($rule['start_date']) > $now) {
            return false;
        }

        if (!empty($rule['end_date']) && strtotime($rule['end_date']) < $now) {
            return false;
        }

        // Verifica categorie
        if (!empty($rule['categories'])) {
            $product_cats = wp_get_post_terms($product->get_id(), 'product_cat', ['fields' => 'ids']);
            if (!array_intersect($rule['categories'], $product_cats)) {
                return false;
            }
        }

        // Verifica ruolo utente
        if (!empty($rule['user_roles'])) {
            $user = wp_get_current_user();
            if (!array_intersect($rule['user_roles'], $user->roles)) {
                return false;
            }
        }

        // Verifica quantità minima
        if (!empty($rule['min_quantity'])) {
            $cart_qty = 0;
            foreach (WC()->cart->get_cart() as $item) {
                if ($item['product_id'] == $product->get_id()) {
                    $cart_qty = $item['quantity'];
                    break;
                }
            }
            if ($cart_qty < $rule['min_quantity']) {
                return false;
            }
        }

        return true;
    }

    /**
     * Calcola il nuovo prezzo
     */
    private function calculate_price($price, $rule, $product) {
        switch ($rule['type']) {
            case 'percentage':
                return $price * (1 - ($rule['value'] / 100));

            case 'fixed':
                return max(0, $price - $rule['value']);

            case 'tiered':
                return $this->calculate_tiered_price($price, $rule, $product);

            case 'time_based':
                return $this->calculate_time_price($price, $rule);

            default:
                return $price;
        }
    }

    /**
     * Prezzo a scaglioni
     */
    private function calculate_tiered_price($price, $rule, $product) {
        $qty = 0;
        foreach (WC()->cart->get_cart() as $item) {
            if ($item['product_id'] == $product->get_id()) {
                $qty = $item['quantity'];
                break;
            }
        }

        $tiers = $rule['tiers'] ?? [];
        krsort($tiers); // Ordina per quantità decrescente

        foreach ($tiers as $min_qty => $discount) {
            if ($qty >= $min_qty) {
                return $price * (1 - ($discount / 100));
            }
        }

        return $price;
    }

    /**
     * Prezzo basato sull'orario
     */
    private function calculate_time_price($price, $rule) {
        $hour = (int) current_time('H');
        $start = (int) ($rule['time_start'] ?? 0);
        $end = (int) ($rule['time_end'] ?? 24);

        if ($hour >= $start && $hour < $end) {
            return $price * (1 - ($rule['value'] / 100));
        }

        return $price;
    }

    /**
     * Mostra prezzo barrato nel carrello
     */
    public function show_discounted_price($price, $cart_item, $cart_item_key) {
        $product = $cart_item['data'];
        $original_price = (float) $product->get_regular_price();
        $current_price = (float) $product->get_price();

        if ($current_price < $original_price) {
            return '' . wc_price($original_price) . ' ' . wc_price($current_price);
        }

        return $price;
    }

    /**
     * Aggiungi menu admin
     */
    public function add_admin_menu() {
        add_submenu_page(
            'woocommerce',
            __('Pricing Dinamico', 'dpe'),
            __('Pricing Dinamico', 'dpe'),
            'manage_woocommerce',
            'dynamic-pricing-engine',
            [$this, 'admin_page']
        );
    }

    /**
     * Pagina admin
     */
    public function admin_page() {
        if (isset($_POST['dpe_save'])) {
            check_admin_referer('dpe_settings');
            $this->save_rules($_POST['rules'] ?? []);
            echo 'Regole salvate!';
        }

        $rules = $this->rules;
        ?>
        
            

            
                

                
                     '', 'type' => 'percentage', 'value' => '', 'active' => true]];
                    }
                    foreach ($rules as $index => $rule) : 
                    ?>
                    
                         #

                        
                            
                                
                                
                                    
                                
                            
                            
                                
                                
                                    
                                
                            
                            
                                
                                
                                    
                                    %
                                
                            
                            
                                
                                
                                     'product_cat', 'hide_empty' => false]);
                                    foreach ($cats as $cat) {
                                        printf(
                                            ' %s
',
                                            $index,
                                            $cat->term_id,
                                            checked(in_array($cat->term_id, $rule['categories'] ?? []), true, false),
                                            esc_html($cat->name)
                                        );
                                    }
                                    ?>
                                
                            
                            
                                
                                
                                    roles as $role_name => $role_info) {
                                        printf(
                                            ' %s
',
                                            $index,
                                            $role_name,
                                            checked(in_array($role_name, $rule['user_roles'] ?? []), true, false),
                                            esc_html($role_info['name'])
                                        );
                                    }
                                    ?>
                                
                            
                            
                                
                                
                                    
                                    -
                                    
                                
                            
                            
                                
                                
                                    
                                        >
                                        
                                    
                                
                            
                        

                        
                        
                    
                    
                

                
                    
                

                
                    
                
            
        

        

        
         $rule) {
            $sanitized[] = [
                'name' => sanitize_text_field($rule['name'] ?? ''),
                'type' => sanitize_text_field($rule['type'] ?? 'percentage'),
                'value' => floatval($rule['value'] ?? 0),
                'categories' => array_map('intval', $rule['categories'] ?? []),
                'user_roles' => array_map('sanitize_text_field', $rule['user_roles'] ?? []),
                'min_quantity' => intval($rule['min_quantity'] ?? 0),
                'start_date' => sanitize_text_field($rule['start_date'] ?? ''),
                'end_date' => sanitize_text_field($rule['end_date'] ?? ''),
                'active' => !empty($rule['active']),
            ];
        }

        update_option('dpe_rules', $sanitized);
        $this->rules = $sanitized;
    }

    /**
     * Registra impostazioni
     */
    public function register_settings() {
        register_setting('dpe_settings', 'dpe_rules');
    }
}

new Dynamic_Pricing_Engine();
Tipi di Regole Supportate

Percentuale - Sconto % su prodotti selezionati
Importo fisso - Sconto in €
A scaglioni - Più compri, più risparmi
Basato sull'orario - Happy hour, orari morti

Risultato atteso: +10-20% margini, +15% conversioni

Best Practices per WooCommerce Plugin Development
1. Performance
// ❌ MAI fare query nel loop
add_action('woocommerce_before_single_product', function() {
    $products = wc_get_products(['limit' => 100]); // Lento!
});

// ✅ Usa transients per caching
add_action('woocommerce_before_single_product', function() {
    $cache_key = 'related_products_' . get_the_ID();
    $products = get_transient($cache_key);

    if (false === $products) {
        $products = wc_get_products(['limit' => 10]);
        set_transient($cache_key, $products, HOUR_IN_SECONDS);
    }
});
2. Sicurezza
// ❌ MAI fidarsi dell'input utente
$price = $_POST['custom_price'];

// ✅ Sanitizza e valida sempre
$price = floatval($_POST['custom_price'] ?? 0);
if ($price < 0 || $price > 999999) {
    wp_die('Prezzo non valido');
}

// ✅ Usa nonce per form
wp_nonce_field('my_action', 'my_nonce');
if (!wp_verify_nonce($_POST['my_nonce'], 'my_action')) {
    wp_die('Security check failed');
}
3. Compatibilità
// ✅ Verifica che WooCommerce sia attivo
if (!class_exists('WooCommerce')) {
    return;
}

// ✅ Usa le versioni minime
add_action('before_woocommerce_init', function() {
    if (class_exists(\Automattic\WooCommerce\Utilities\FeaturesUtil::class)) {
        \Automattic\WooCommerce\Utilities\FeaturesUtil::declare_compatibility('custom_order_tables', __FILE__);
    }
});

// ✅ Hook con priorità corretta
add_filter('woocommerce_product_get_price', 'my_filter', 99, 2); // Priorità alta
4. Debug e Logging
// ✅ Logga errori per debug
if (defined('WP_DEBUG') && WP_DEBUG) {
    error_log('WooCommerce Debug: ' . print_r($data, true));
}

// ✅ Usa WC_Logger
$logger = wc_get_logger();
$logger->info('Messaggio informativo', ['source' => 'my-plugin']);
$logger->error('Errore critico', ['source' => 'my-plugin']);

Come Testare i Tuoi Plugin
Ambiente di Test
# Crea un sito di test con WP-CLI
wp core download --version=latest --path=/var/www/test-site
wp config create --dbname=test_db --dbuser=root --dbpass=password
wp db create
wp core install --url=test.local --title="Test Site" --admin_user=admin --admin_password=password --admin_email=admin@test.local

# Installa WooCommerce
wp plugin install woocommerce --activate

# Crea prodotti di test
wp wc product create --name="Test Product" --regular_price=19.99 --user=admin

# Attiva il tuo plugin
wp plugin activate my-custom-plugin
Unit Testing
// tests/test-my-plugin.php
class MyPluginTest extends WP_UnitTestCase {

    public function test_price_calculation() {
        $product = new WC_Product_Simple();
        $product->set_regular_price(100);
        $product->save();

        $calculated = apply_filters('woocommerce_product_get_price', 100, $product);

        $this->assertLessThan(100, $calculated, 'Il prezzo scontato deve essere minore');
    }
}

Conclusione
Il codice custom per WooCommerce non è solo per sviluppatori esperti. Con gli esempi di questa guida, puoi implementare funzionalità che aumentano concretamente le conversioni del tuo store:

Upsell intelligente → +15-25% AOV
Notifiche stock → Recupero 15-25% vendite perse
Checkout ottimizzato → +20-35% completamento
Pricing dinamico → +10-20% margini

Prossimi Passi

Scegli un plugin dalla lista e implementalo nel tuo ambiente di test
Personalizza le regole in base al tuo business
Monitora i risultati con Google Analytics e WooCommerce Reports
Itera in base ai dati raccolti

Risorse Utili

WooCommerce Developer Documentation
WordPress Plugin Developer Handbook
WooCommerce REST API


Sei uno sviluppatore WordPress? Condividi questa guida con i tuoi clienti e mostragli il valore del codice custom.
Sei uno store owner? Contatta un developer WooCommerce certificato per implementare queste soluzioni sul tuo store.
Hai domande o suggerimenti? Lascia un commento qui sotto!



OpenCode: L'AI che Programma Mentre Dormi - La Guida Pratica per Sviluppatori WordPress
Emilio Petrozzi — Thu, 09 Apr 2026 09:11:03 +0000
OpenCode: L'AI che Programma Mentre Dormi
Cinque milioni di sviluppatori usano gia un agente AI che non aspetta di essere interpellato. Si sveglia ogni 30 minuti, controlla cosa c'e da fare, e si mette al lavoro. Ha accesso alla tua shell, al tuo file system, e a ogni API key che gli hai fornito.
Non e uno slogan pubblicitario. E la descrizione di quello che OpenCode fa oggi, su macchine reali, per team di sviluppo reali.
La domanda interessante non e se questo tipo di strumento sia impressionante. Chiaramente lo e. La domanda interessante e: perche la maggior parte degli sviluppatori tratta ancora l'AI come un autocomplete glorificato?

Cosa Rende Diverso OpenCode
Ogni strumento di coding AI fa la stessa affermazione di base: ti aiuta a scrivere codice piu velocemente. GitHub Copilot, Cursor, Windsurf - vivono tutti nel tuo IDE e rispondono quando chiedi qualcosa. Sono reattivi. Tu guidi; loro suggeriscono.
OpenCode lavora su una premessa completamente diversa. Tratta l'AI come agente e te come architetto. Tu descrivi cosa vuoi costruire. Lo strumento capisce quali file sono rilevanti, li legge, costruisce un piano, e lo esegue. Tu revisioni quello che ha fatto.
E una relazione genuinamente diversa con la macchina. Non migliore per ogni situazione, ma abbastanza diversa da cambiare come pensi a cosa sia realmente il lavoro di programmazione.

L'Architettura che Rende Tutto Possibile
OpenCode gira come server in background, non come un processo che apri quando ti serve. Un client leggero si connette, che sia un'interfaccia terminale, un'app desktop, o un'estensione VS Code. Questo e importante perche significa che l'agente puo mantenere stato persistente ed eseguire sessioni multiple in parallelo.
Esecuzione Parallela
Puoi puntare un agente verso un refactor di un microservizio backend e un altro verso lavoro CSS frontend, eseguendo simultaneamente, nello stesso repository. I vecchi tool CLI bloccano il terminale finche un task non completa. OpenCode tratta il parallelismo come feature di prima classe.
Gerarchia degli Agent
Ci sono due agent principali con cui la maggior parte degli utenti interagisce:
Plan Mode e read-only. Esplora il tuo codebase, mappa la struttura rilevante, e produce una strategia di implementazione passo-passo. Non puo toccare un singolo file. Lo usi per pensare a cosa stai per fare.
Build Mode esegue il piano. Ha pieno accesso read/write, puo eseguire comandi shell, modificare file, e lanciare test. Una volta verificato che la proposta dell'agente Plan ha senso, passi a Build e lo lasci girare.
La separazione sembra semplice. In pratica previene una categoria massiccia di errori, perche il modello ragiona sul problema prima di iniziare a toccare le cose.
Compaction Agent
C'e anche un agente interno di Compaction che gira silenziosamente in background. Man mano che la cronologia della conversazione cresce e riempie la context window, riassume le parti rilevanti e mantiene il modello primario focalizzato. Senza questo, le sessioni lunghe degradano. Il modello inizia a dimenticare le istruzioni precedenti.

L'Integrazione LSP: Il Vero Game-Changer
Qui e dove OpenCode si separa davvero dal resto, e la maggior parte dei contenuti tutorial lo salta completamente.
Gli agent AI di coding standard leggono i file come testo. Fanno grep di stringhe, matchano pattern, e indovinano le relazioni strutturali. Funziona bene per task semplici. Si rompe durante refactor su larga scala in codebase complessi.
OpenCode puo connettersi direttamente ai tool Language Server Protocol (LSP), gli stessi sistemi che il tuo IDE usa per capire il codice semanticamente. Abilitalo con:
OPENCODE_EXPERIMENTAL_LSP_TOOL=true
E improvvisamente l'agente ha accesso a:

goToDefinition - naviga alle definizioni
findReferences - trova tutti i riferimenti
call hierarchy analysis - analizza la gerarchia delle chiamate
real-time diagnostics - diagnostiche in tempo reale

Supporta TypeScript, Python, Java, Rust, Go, PHP, e altri.
La Differenza Pratica
Quando l'AI rinomina un metodo polimorfico attraverso 200 file di servizio, non sta indovinando quali occorrenze cambiare basandosi sul string matching. Usa riferimenti semantici. Sa esattamente cosa e una definizione, cosa e una chiamata, e cosa e un'annotazione di tipo. Il refactor e type-safe.
E se l'agente scrive qualcosa di sbagliato, l'LSP lancia diagnostiche di errore in tempo reale. L'agente vede il problema e lo corregge prima che tu debba revisionare.

Multi-Provider: La Liberta di Scelta
OpenCode supporta OpenAI, Anthropic, Google, e modelli locali via Ollama. Quando Gemini 2.5 Pro e uscito, gli utenti hanno cambiato un blocco nel file di configurazione e hanno continuato a lavorare.
Questo non e un vantaggio banale. Il mercato dell'infrastruttura AI si sposta costantemente: la qualita dei modelli cambia, i prezzi cambiano, i termini di servizio cambiano. Qualsiasi strumento che ti lega a un singolo provider e una responsabilita.
L'architettura provider-agnostica di OpenCode significa che puoi eseguire modelli costosi per lavoro architetturale complesso e modelli veloci ed economici per boilerplate e scaffolding di test, cambiando dinamicamente nella stessa sessione.

OpenCode per Sviluppatori WordPress
Per noi sviluppatori WordPress, OpenCode offre opportunita uniche:
1. Sviluppo Plugin Automatizzato
"Analizza il plugin WooCommerce e crea un'estensione che 
aggiunga un campo personalizzato per la data di consegna 
preferita nel checkout"
OpenCode leggera i file rilevanti di WooCommerce, capira gli hook necessari, e generera codice funzionante.
2. Refactoring Temi
Con l'integrazione LSP per PHP, puoi:

Rinominare funzioni attraverso tutto il tema
Trovare riferimenti a hook deprecati
Identificare codice non utilizzato

3. Debug Automatico
"Il sito mostra errore 500 sulla pagina shop. 
Analizza i log e identifica la causa."
L'agente puo leggere i log, identificare il file problematico, e suggerire o implementare la correzione.
4. Documentazione Automatica
"Genera documentazione PHPDoc per tutte le funzioni 
pubbliche di questo plugin"

Configurazione Rapida
1. Installazione
# macOS/Linux
curl -fsSL https://get.opencode.ai | sh

# Oppure via npm
npm install -g @opencode-ai/cli
2. Configurazione Provider
Crea ~/.opencode/config.json:
{
  "providers": {
    "openai": {
      "apiKey": "sk-..."
    },
    "anthropic": {
      "apiKey": "sk-ant-..."
    }
  },
  "defaultProvider": "anthropic",
  "defaultModel": "claude-sonnet-4"
}
3. Abilita LSP
export OPENCODE_EXPERIMENTAL_LSP_TOOL=true
4. Crea AGENTS.md
Nella root del tuo progetto WordPress:
# Project Guidelines

## WordPress Coding Standards
- Segui WordPress Coding Standards
- Usa hook e filtri invece di modificare core
- Prefissa tutte le funzioni con il nome del tema/plugin

## File Structure
- /wp-content/themes/tuo-tema/
- /wp-content/plugins/tuo-plugin/

## Testing
- Esegui test prima di ogni commit
- Verifica compatibilita PHP 7.4+

Dove Sta Andando Tutto Questo
I team piu ambiziosi che usano OpenCode non lo trattano come un tool CLI. Usano framework come Oh My OpenCode per costruire veri sistemi multi-agente dove un manager agent coordina subagent specializzati, ognuno ottimizzato per un tipo specifico di lavoro.
L'orchestrazione, non il modello, e dove avviene il vero lavoro. Quali file l'agente legge. Quali sistemi esterni puo toccare. Come gestisce gli errori. Cosa fa quando e incerto. Il modello stesso e sempre piu una commodity. Puoi sostituirlo.
Questo e l'insight reale sepolto nell'architettura di OpenCode: lo strumento tratta l'intelligenza come intercambiabile e l'agenzia come la cosa che vale la pena costruire con cura.
L'LLM puo essere sostituito. La configurazione del progetto, i permessi dei tool, le integrazioni workflow, il file AGENTS.md che codifica gli standard del tuo team - quell'infrastruttura persiste attraverso ogni cambio di modello.

Conclusione
Inizia con le basi. Inizializza un progetto, esegui alcune sessioni in Plan mode, blocca la tua configurazione dei permessi prima che l'agente tocchi qualcosa di distruttivo. Presta attenzione a cosa l'agente sbaglia e raffina il tuo file AGENTS.md per affrontarlo. Il sistema impara da quel feedback in modo molto diretto: scrivi istruzioni migliori, produce output migliori.
Gli sviluppatori che trattano questo come un sostituto di autocomplete passivo ottengono guadagni incrementali. Quelli che costruiscono attorno ad esso una vera infrastruttura di agent stanno delegando intere categorie di lavoro di ingegneria.
Il divario tra questi due gruppi continuera a crescere.

Pubblicato il 9 Aprile 2026



Hook WordPress: Azioni e Filter per Plugin Professionali
Emilio Petrozzi — Sat, 21 Mar 2026 19:20:06 +0000
Hook WordPress: Azioni e Filter per Plugin Professionali
Guida Completa 2026 per Sviluppatori WordPress

🎯 Introduzione
Gli hook sono il cuore pulsante di WordPress. Se vuoi sviluppare plugin professionali, temi child avanzati o semplicemente personalizzare il tuo sito senza modificare i file core, devi padroneggiare questo sistema.
In questa guida scoprirai:

✅ La differenza tra Actions e Filters
✅ 30+ esempi pratici pronti all'uso
✅ Le best practice per hook sicuri ed efficienti
✅ Come intercettare eventi e modificare contenuti dinamicamente
✅ Gli hook essenziali che ogni sviluppatore deve conoscere

Prerequisiti: Conoscenza base di PHP e WordPress
Tempo di lettura: 15-20 minuti

📚 Cosa Sono gli Hook WordPress?
Definizione
Un hook è un punto di aggancio nel codice di WordPress che ti permette di eseguire il tuo codice personalizzato in momenti specifici del ciclo di vita di WordPress.
Perché Sono Importanti?



Vantaggio
Descrizione




Non Invasivo
Non modifichi mai i file core di WordPress


Aggiornamenti Sicuri
Puoi aggiornare WordPress senza perdere le tue modifiche


Modulare
Ogni funzionalità è isolata e indipendente


Estensibile
Altri sviluppatori possono estendere il tuo lavoro



I Due Tipi di Hook
// 1. ACTIONS - Eseguono codice in un momento specifico
do_action('nome_hook', $param1, $param2);
add_action('nome_hook', 'tua_funzione', $priority, $accepted_args);

// 2. FILTERS - Modificano e restituiscono dati
apply_filters('nome_hook', $value, $param1);
add_filter('nome_hook', 'tua_funzione', $priority, $accepted_args);

⚡ Actions vs Filters: La Differenza Chiave
Actions (Azioni)
Cosa fanno: Eseguono codice quando succede qualcosa.
Quando usarle:

Inviare email
Scrivere nel database
Inviare notifiche
Caricare script e stili
Registrare custom post type

Esempio:
// Esegue una funzione quando un post viene pubblicato
add_action('publish_post', 'invia_notifica_social', 10, 2);

function invia_notifica_social($ID, $post) {
    // Codice per inviare notifica ai social
    error_log('Post pubblicato: ' . $post->post_title);
}
Filters (Filtri)
Cosa fanno: Modificano dati e restituiscono il valore modificato.
Quando usarli:

Modificare contenuti prima del display
Cambiare titoli dinamicamente
Alterare query del database
Personalizzare excerpt

Esempio:
// Aggiunge testo alla fine di ogni contenuto
add_filter('the_content', 'aggiungi_firma_articolo');

function aggiungi_firma_articolo($content) {
    if (is_single()) {
        $content .= '📝 Articolo scritto da Mario Rossi';
    }
    return $content; // ⚠️ IMPORTANTE: devi restituire il valore!
}
Tabella Comparativa



Caratteristica
Actions
Filters




Scopo
Eseguire azioni
Modificare dati


Return
Non necessario
OBBLIGATORIO


Funzione
do_action()
apply_filters()


Registrazione
add_action()
add_filter()


Esempio
Invio email
Modifica titolo




🔥 30+ Esempi Pratici di Hook Essenziali
📌 Hook per Plugin Development
1. Inizializzazione Plugin
// Eseguito dopo che WordPress è caricato
add_action('init', 'mio_plugin_init');

function mio_plugin_init() {
    // Carica traduzioni
    load_plugin_textdomain('mio-plugin', false, dirname(plugin_basename(__FILE__)) . '/languages');

    // Registra custom post type
    register_post_type('progetto', array(
        'public' => true,
        'label' => 'Progetti'
    ));
}
2. Attivazione Plugin
// Eseguito quando il plugin viene attivato
register_activation_hook(__FILE__, 'mio_plugin_attiva');

function mio_plugin_attiva() {
    // Crea tabelle database
    global $wpdb;
    $table_name = $wpdb->prefix . 'mio_plugin_dati';

    $charset_collate = $wpdb->get_charset_collate();

    $sql = "CREATE TABLE $table_name (
        id mediumint(9) NOT NULL AUTO_INCREMENT,
        data datetime DEFAULT '0000-00-00 00:00:00' NOT NULL,
        PRIMARY KEY  (id)
    ) $charset_collate;";

    require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
    dbDelta($sql);

    // Imposta opzioni default
    add_option('mio_plugin_version', '1.0.0');
}
3. Disattivazione Plugin
// Eseguito quando il plugin viene disattivato
register_deactivation_hook(__FILE__, 'mio_plugin_disattiva');

function mio_plugin_disattiva() {
    // Pulisci cron jobs
    wp_clear_scheduled_hook('mio_plugin_evento_giornaliero');

    // NON cancellare i dati! Lascia all'utente la scelta
}
4. Aggiunta Menu Admin
add_action('admin_menu', 'mio_plugin_menu_admin');

function mio_plugin_menu_admin() {
    add_menu_page(
        'Mio Plugin',           // Titolo pagina
        'Mio Plugin',           // Titolo menu
        'manage_options',       // Capacità richiesta
        'mio-plugin',           // Slug
        'mio_plugin_pagina',    // Funzione callback
        'dashicons-admin-settings', // Icona
        30                      // Posizione
    );
}
5. Caricamento Script e Stili
add_action('wp_enqueue_scripts', 'mio_plugin_carica_risorse');

function mio_plugin_carica_risorse() {
    // Carica CSS
    wp_enqueue_style(
        'mio-plugin-style',
        plugin_dir_url(__FILE__) . 'css/style.css',
        array(),
        '1.0.0'
    );

    // Carica JavaScript
    wp_enqueue_script(
        'mio-plugin-script',
        plugin_dir_url(__FILE__) . 'js/script.js',
        array('jquery'),
        '1.0.0',
        true // Carica nel footer
    );

    // Passa dati a JavaScript
    wp_localize_script('mio-plugin-script', 'mioPluginData', array(
        'ajaxUrl' => admin_url('admin-ajax.php'),
        'nonce' => wp_create_nonce('mio_plugin_nonce')
    ));
}

📌 Hook per Modificare Contenuti
6. Modifica Titolo Post
add_filter('the_title', 'mio_prefix_titolo', 10, 2);

function mio_prefix_titolo($title, $post_id) {
    if (is_single() && !is_admin()) {
        $title = '🔥 ' . $title;
    }
    return $title;
}
7. Aggiungi Contenuto Dopo il Post
add_filter('the_content', 'aggiungi_contenuto_dopo_post');

function aggiungi_contenuto_dopo_post($content) {
    if (is_single() && in_the_loop() && is_main_query()) {
        $content .= '
        
            📧 Iscriviti alla newsletter per altri articoli come questo!
            [newsletter-form]
        ';
    }
    return $content;
}
8. Modifica Excerpt
add_filter('excerpt_length', 'mio_excerpt_lunghezza');

function mio_excerpt_lunghezza($length) {
    return 30; // Default è 55
}

add_filter('excerpt_more', 'mio_excerpt_piu');

function mio_excerpt_piu($more) {
    return '... Leggi tutto →';
}
9. Personalizza URL Autore
add_filter('author_link', 'mio_custom_author_link', 10, 3);

function mio_custom_author_link($link, $author_id, $author_nicename) {
    return home_url('/team/' . $author_nicename . '/');
}
10. Filtra Query Principale
add_action('pre_get_posts', 'mio_filtra_query_homepage');

function mio_filtra_query_homepage($query) {
    if ($query->is_main_query() && $query->is_home()) {
        $query->set('posts_per_page', 10);
        $query->set('orderby', 'date');
        $query->set('order', 'DESC');
    }
}

📌 Hook per WooCommerce
11. Modifica Prezzo Prodotto
add_filter('woocommerce_product_get_price', 'mio_modifica_prezzo', 10, 2);

function mio_modifica_prezzo($price, $product) {
    // Applica sconto del 10% ai prodotti sopra 100€
    if ($price > 100) {
        $price = $price * 0.9;
    }
    return $price;
}
12. Aggiungi Campo Checkout
add_action('woocommerce_after_order_notes', 'mio_campo_checkout');

function mio_campo_checkout($checkout) {
    echo '';

    woocommerce_form_field('codice_fiscale', array(
        'type' => 'text',
        'class' => array('form-row-wide'),
        'label' => __('Codice Fiscale'),
        'placeholder' => __('Inserisci il tuo CF'),
        'required' => true,
    ), $checkout->get_value('codice_fiscale'));

    echo '';
}
13. Email Personalizzata Ordine
add_filter('woocommerce_email_subject_customer_completed_order', 'mio_oggetto_email', 10, 2);

function mio_oggetto_email($subject, $order) {
    return '🎉 Il tuo ordine #' . $order->get_id() . ' è stato completato!';
}
14. Azione Dopo Acquisto
add_action('woocommerce_checkout_order_processed', 'mio_dopo_acquisto', 10, 3);

function mio_dopo_acquisto($order_id, $posted_data, $order) {
    // Invia notifica Slack
    // Aggiorna CRM
    // Invia SMS
    error_log('Ordine processato: ' . $order_id);
}

📌 Hook per Sicurezza
15. Sanitizzazione Input
// MAI fidarsi degli input utente!
add_action('admin_post_mio_form', 'mio_elabora_form');

function mio_elabora_form() {
    // Verifica nonce
    check_admin_referer('mio_form_action', 'mio_nonce');

    // Sanitizza input
    $nome = sanitize_text_field($_POST['nome']);
    $email = sanitize_email($_POST['email']);
    $url = esc_url_raw($_POST['website']);

    // Salva dati
    // ...
}
16. Escape Output
// SEMPRE fare escape dell'output!
function mio_display_dati() {
    echo '' . esc_html($titolo) . '';
    echo 'Link';
    echo '' . esc_attr($attributo) . '';
}
17. Verifica Permessi
add_action('admin_init', 'mio_verifica_permessi');

function mio_verifica_permessi() {
    if (!current_user_can('manage_options')) {
        wp_die('Non hai i permessi per accedere a questa pagina.');
    }
}

📌 Hook per Performance
18. Disabilita Emoji (Risparmio Query)
remove_action('wp_head', 'print_emoji_detection_script', 7);
remove_action('admin_print_scripts', 'print_emoji_detection_script');
remove_action('wp_print_styles', 'print_emoji_styles');
remove_action('admin_print_styles', 'print_emoji_styles');
19. Disabilita Embed OEmbed
add_action('init', 'mio_disabilita_embed', 1);

function mio_disabilita_embed() {
    remove_action('rest_api_init', 'wp_oembed_register_route');
    remove_filter('rest_pre_serve_request', 'wp_oembed_send_header');
    remove_action('wp_head', 'wp_oembed_add_discovery_links');
    remove_action('wp_head', 'wp_oembed_add_host_js');
}
20. Limit Heartbeat API
add_filter('heartbeat_settings', 'mio_limit_heartbeat');

function mio_limit_heartbeat($settings) {
    $settings['interval'] = 60; // Default è 15 secondi
    return $settings;
}

📌 Hook per SEO
21. Aggiungi Meta Tag
add_action('wp_head', 'mio_meta_tag_custom');

function mio_meta_tag_custom() {
    if (is_single()) {
        echo '';
        echo '';
    }
}
22. Modifica Title Tag
add_filter('document_title_parts', 'mio_custom_title');

function mio_custom_title($title) {
    if (is_home()) {
        $title['title'] = 'Blog - ' . get_bloginfo('name');
    }
    return $title;
}
23. Aggiungi Schema.org
add_action('wp_head', 'mio_schema_org');

function mio_schema_org() {
    if (is_single()) {
        ?>
        
        


📌 Hook per Custom Post Type
24. Registra Custom Post Type
add_action('init', 'mio_registra_cpt_progetto');

function mio_registra_cpt_progetto() {
    $labels = array(
        'name' => 'Progetti',
        'singular_name' => 'Progetto',
        'add_new' => 'Aggiungi Nuovo',
        'add_new_item' => 'Aggiungi Nuovo Progetto',
        'edit_item' => 'Modifica Progetto',
        'new_item' => 'Nuovo Progetto',
        'view_item' => 'Vedi Progetto',
        'search_items' => 'Cerca Progetti',
        'not_found' => 'Nessun progetto trovato',
        'menu_name' => 'Progetti'
    );

    $args = array(
        'labels' => $labels,
        'public' => true,
        'has_archive' => true,
        'show_in_rest' => true, // Abilita Gutenberg
        'supports' => array('title', 'editor', 'thumbnail', 'excerpt'),
        'menu_icon' => 'dashicons-portfolio',
        'rewrite' => array('slug' => 'progetti')
    );

    register_post_type('progetto', $args);
}
25. Registra Tassonomia Custom
add_action('init', 'mio_registra_tassonomia_cliente', 0);

function mio_registra_tassonomia_cliente() {
    $labels = array(
        'name' => 'Clienti',
        'singular_name' => 'Cliente',
        'search_items' => 'Cerca Clienti',
        'all_items' => 'Tutti i Clienti',
        'edit_item' => 'Modifica Cliente',
        'add_new_item' => 'Aggiungi Nuovo Cliente',
        'menu_name' => 'Clienti'
    );

    $args = array(
        'labels' => $labels,
        'public' => true,
        'hierarchical' => false,
        'show_in_rest' => true,
        'rewrite' => array('slug' => 'cliente')
    );

    register_taxonomy('cliente', 'progetto', $args);
}
26. Meta Box per CPT
add_action('add_meta_boxes', 'mio_aggiungi_meta_box');

function mio_aggiungi_meta_box() {
    add_meta_box(
        'mio_meta_box',
        'Dettagli Progetto',
        'mio_meta_box_callback',
        'progetto',
        'normal',
        'high'
    );
}

function mio_meta_box_callback($post) {
    wp_nonce_field('mio_meta_box_action', 'mio_meta_box_nonce');

    $valore = get_post_meta($post->ID, '_mio_metakey', true);

    echo 'Budget:';
    echo '';
}
27. Salva Meta Box
add_action('save_post_progetto', 'mio_salva_meta_box', 10, 2);

function mio_salva_meta_box($post_id, $post) {
    // Verifica nonce
    if (!isset($_POST['mio_meta_box_nonce']) || 
        !wp_verify_nonce($_POST['mio_meta_box_nonce'], 'mio_meta_box_action')) {
        return;
    }

    // Verifica autosave
    if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
        return;
    }

    // Verifica permessi
    if (!current_user_can('edit_post', $post_id)) {
        return;
    }

    // Salva dato
    if (isset($_POST['mio_field'])) {
        update_post_meta($post_id, '_mio_metakey', sanitize_text_field($_POST['mio_field']));
    }
}

📌 Hook per Utility
28. Redirect Dopo Login
add_filter('login_redirect', 'mio_redirect_login', 10, 3);

function mio_redirect_login($redirect_to, $request, $user) {
    if (isset($user->roles) && is_array($user->roles)) {
        if (in_array('administrator', $user->roles)) {
            return admin_url();
        } else {
            return home_url('/dashboard/');
        }
    }
    return $redirect_to;
}
29. Nascondi Barra Admin
add_filter('show_admin_bar', '__return_false');
30. Cambia Logo Login
add_action('login_enqueue_scripts', 'mio_logo_login');

function mio_logo_login() {
    echo '';
}
31. Footer Personalizzato Admin
add_filter('admin_footer_text', 'mio_footer_admin');

function mio_footer_admin($text) {
    return 'Sviluppato con ❤️ da MrTux';
}
32. Cron Job Personalizzato
// Registra evento cron all'attivazione plugin
register_activation_hook(__FILE__, 'mio_attiva_cron');

function mio_attiva_cron() {
    if (!wp_next_scheduled('mio_evento_giornaliero')) {
        wp_schedule_event(time(), 'daily', 'mio_evento_giornaliero');
    }
}

// Esegui azione
add_action('mio_evento_giornaliero', 'mio_esegui_task');

function mio_esegui_task() {
    // Invia report email
    // Pulisci database
    // Aggiorna cache
    error_log('Task giornaliero eseguito');
}

// Rimuovi cron alla disattivazione
register_deactivation_hook(__FILE__, 'mio_disattiva_cron');

function mio_disattiva_cron() {
    wp_clear_scheduled_hook('mio_evento_giornaliero');
}

🎯 Best Practice per Hook Professionali
1. Usa Priority Correttamente
// ❌ SBAGLIATO: Priority default (10) potrebbe confliggere
add_action('init', 'mia_funzione');

// ✅ CORRETTO: Specifica priority esplicita
add_action('init', 'mia_funzione', 20);  // Dopo i default
add_action('init', 'mia_funzione', 5);   // Prima dei default
2. Accetta Tutti gli Argomenti
// ❌ SBAGLIATO: Perdi dati
add_action('publish_post', 'mia_funzione');
function mia_funzione($ID) {
    // ...
}

// ✅ CORRETTO: Accetta tutti gli argomenti
add_action('publish_post', 'mia_funzione', 10, 2);
function mia_funzione($ID, $post) {
    // Ora hai accesso a $post completo
}
3. Namespacing per Evitare Conflitti
// ❌ SBAGLIATO: Nomi generici
add_action('init', 'init_function');

// ✅ CORRETTO: Prefix unico
add_action('init', 'mio_plugin_init_function');

// ✅ OTTIMO: Namespace PHP
namespace MioPlugin;

add_action('init', __NAMESPACE__ . '\init_function');
4. Documenta i Tuoi Hook
/**
 * Hook personalizzato per dopo la pubblicazione
 *
 * @since 1.0.0
 * @param int $post_id ID del post pubblicato
 * @param WP_Post $post Oggetto post completo
 */
do_action('mio_plugin_dopo_pubblicazione', $post_id, $post);
5. Usa Hook Removibili
// ✅ Permetti ad altri di rimuovere il tuo hook
add_action('wp_head', 'mio_funzione_removibile');

// Altri sviluppatori possono fare:
remove_action('wp_head', 'mio_funzione_removibile');

📋 Checklist Sviluppo Plugin con Hook
Prima di Pubblicare

[ ] Tutti gli hook hanno prefix unico?
[ ] Le funzioni restituiscono valori (per i filter)?
[ ] Gli input sono sanitizzati?
[ ] L'output è escaped?
[ ] I nonce sono verificati?
[ ] I permessi sono controllati?
[ ] Gli hook di attivazione/disattivazione sono presenti?
[ ] I cron job sono puliti alla disattivazione?

Performance

[ ] Gli hook sono registrati solo quando necessario?
[ ] Le query database sono minimizzate?
[ ] Gli script sono caricati solo nelle pagine necessarie?
[ ] La cache è utilizzata appropriatamente?


🐛 Troubleshooting Comune
Hook Non Funziona
Problema: Il tuo hook non viene eseguito.
Soluzioni:

Verifica che l'hook esista: do_action_deprecated() nei log
Controlla la priority: potrebbe essere eseguito troppo tardi
Verifica i permessi: current_user_can()
Controlla condizioni: is_admin(), is_single(), etc.

Filter Non Modifica Nulla
Problema: Il filter non altera il valore.
Soluzioni:

Assicurati di RETURN: return $value;
Verifica la priority: altri filter potrebbero sovrascrivere
Controlla il tipo di dato restituito

Conflitti tra Plugin
Problema: Due plugin usano lo stesso hook name.
Soluzioni:

Usa prefix unici nei nomi delle funzioni
Specifica priority diverse
Usa namespace PHP


📚 Risorse Utili
Documentazione Ufficiale

WordPress Plugin API
Action Reference
Filter Reference

Strumenti di Debug
// Lista tutti gli hook registrati
global $wp_filter;
print_r(array_keys($wp_filter));

// Vedi chi è agganciato a un hook
print_r($wp_filter['init']);

// Debug hook execution
add_action('all', function($hook) {
    error_log('Hook eseguito: ' . $hook);
});
Plugin Utili

Query Monitor: Debug hook e query
Hook Sniffer: Vedi tutti gli hook eseguiti
What The File: Vedi quale template è caricato


🎓 Conclusione
Gli hook WordPress sono uno strumento potente che separa i developer principianti da quelli professionisti. Padroneggiandoli, potrai:
✅ Creare plugin modulari e mantenibili

✅ Personalizzare WordPress senza modificare il core

✅ Integrarti con qualsiasi tema o plugin

✅ Costruire soluzioni scalabili e sicure
Prossimi Passi:

Sperimenta con gli esempi in questa guida
Crea un plugin di test per praticare
Esplora il WordPress Hook Reference
Contribuisci alla community con i tuoi hook


💬 Hai Domande?
Lascia un commento o contattaci per consulenza sullo sviluppo di plugin WordPress professionali!
📧 Newsletter: Iscriviti per ricevere altri tutorial come questo!

Ultimo aggiornamento: Marzo 2026

Tempo di lettura: 20 minuti

Parole: 2.500+



Installare VestaCP e WordPress su server VPS con Centos 7
Emilio Petrozzi — Mon, 02 Dec 2019 18:46:47 +0000
In questa breve guida vedremo come installare WordPress su un server VPS con Linux Centos 7. In tal modo potremo avere immediatamente disponibile Nginx configurato con l'ultima versione di PHP-FPM, ovvero la 7.4.

Prerequisiti
Sarà necessario disporre di un server VPS (oppure un server dedicato) con installato Linux Centos 7. Le risorse di sistema minime richieste sono di almeno di 1 GB di memoria RAM.
Configurazione di Linux Centos 7
Attraverso la password dell'utente root procediamo con il login sul server appena installato:

pc@locale# ssh root@ip-server-remoto


Quindi aggiorniamo i pacchetti installati su Centos 7:

server@remoto# yum update


Installiamo, se non già installati, i programmi che andremo ad utilizzare in seguito:

server@remoto# yum install mc nano curl


Rimuoviamo la timezone attuale e impostiamola sull'ora italiana:

server@remoto# rm /etc/localtime
server@remoto# ln -s /usr/share/zoneinfo/Europe/Rome /etc/localtime


Installazione di VestaCP
Prima dell'installazione di Vesta Control Panel sarà necessario rimuovere eventuali installazioni di Apache, Nginx oppure del database MySQL. Di solito il web server che viene installato di default è Apache e per rimuoverlo completamente utilizzaremo i seguenti comandi:

server@remoto# yum erase httpd httpd-tools apr apr-util


Quindi utilizzaremo il seguente comando per verificare se tutti i pacchetti relativi al web server Apache sono stati rimossi:

server@remoto# rpm -qa | grep httpd


Rimoviamo la cartella radice del server web:

server@remoto# rm -rf /var/www


Rimozione dei file di configurazione:

server@remoto# rm -rf /etc/httpd


Rimozione dei moduli Apache:

server@remoto# rm -rf /usr/lib64/httpd


Rimozione dell'utente Apache:

server@remoto# userdel -r apache


Con il seguente comando ci accertiamo che non sia presente l'utente Apache in /etc/passwd:

server@remoto# grep "apache" /etc/passwd


Infine verifichiamo se il web server risulta attivo o meno:

server@remoto# systemctl status httpd


Arrivati a questo punto possiamo procedere con l'installazione del pannello di controllo VestaCP.
In particolare procederemo all'installazione del pannello di controllo configurandolo in modo da poter essere utilizzato con il web server Nginx e il modulo autonomo php-fpm che provvederà ad interpretare il codice PHP presente sulle pagine web.
A tale scopo utilizzeremo i seguenti comandi, come indicato nelle relative istruzioni per l'installazione:
Scarichiamo lo script di installazione:

server@remoto# curl -O http://vestacp.com/pub/vst-install.sh


E lanciamo tale script con i seguenti parametri:

server@remoto# bash vst-install.sh --nginx yes --phpfpm yes --apache no --named yes --remi yes --vsftpd no --proftpd no --iptables yes --fail2ban yes --quota no --exim no --dovecot no --spamassassin no --clamav no --softaculous no --mysql yes --postgresql no --hostname server.nomehost.it --email info@nomehost.it --password password-pannello


I parametri sopra indicati installeranno solo il server web Nginx, il relativo modulo php e il firewall fail2ban, evitando quindi di installare i server email e ftp.
Ovviamente sarà necessario sostituire server.nomehost.it con il proprio sotto-dominio opportunamente configurato attraverso il pannello di getione DNS del proprio registrar.
Durante l'installazione uno dei problemi più comuni riscontrati è relativo all'errata gestione dei collegamenti simbolici sia del web server Nginx che del firewall fail2ban.
In tal caso sarà necessario interrompere momentaneamente l'installazione attraverso il comando CTRL-C e apportare le seguenti modifiche. Nel caso sottostante la procedura è riferita al solo sever Nginx ma la procedura è la stessa per fail2ban.

# nano /etc/sysctl.d/disable_ipv6.conf


net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1

# nano /usr/lib/systemd/system/nginx.service


Trovare:

PIDFile=/var/run/nginx.pid


Sostituire con:

PIDFile=/run/nginx.pid




# nano /etc/nginx/nginx.conf


Trovare:

pid /var/run/nginx.pid;


Sostituire con:

pid /run/nginx.pid;


Infine rendere effettivi gli aggiornamento con i seguenti comandi:

# systemctl daemon-reload
# reboot


A questo punto l'installazione sarà completata in circa 10 minuti e potremo effettuare il login sul pannello di controllo di VestaCP.



VestaCP su Centos 7





Infine possiamo procedere con l'installazione e la configurazione di WordPress attraverso WP-CLI, come descritto nel relativo tutorial.

Caratteristica	Actions	Filters
Scopo	Eseguire azioni	Modificare dati
Return	Non necessario	OBBLIGATORIO
Funzione	`do_action()`	`apply_filters()`
Registrazione	`add_action()`	`add_filter()`
Esempio	Invio email	Modifica titolo

Comando	Funzione
`docker-compose up -d`	Avvia tutti i servizi in background
`docker-compose down`	Ferma e rimuove i container
`docker-compose down -v`	Ferma e rimuove anche i volumi (cancella il DB)
`docker-compose exec app bash`	Apre una shell dentro il container PHP
`docker-compose logs -f`	Mostra i log di tutti i container in tempo reale
`docker-compose restart`	Riavvia tutti i servizi



	%
	'product_cat', 'hide_empty' => false]); foreach ($cats as $cat) { printf( ' %s ', $index, $cat->term_id, checked(in_array($cat->term_id, $rule['categories'] ?? []), true, false), esc_html($cat->name) ); } ?>
	roles as $role_name => $role_info) { printf( ' %s ', $index, $role_name, checked(in_array($role_name, $rule['user_roles'] ?? []), true, false), esc_html($role_info['name']) ); } ?>
	-
	>

Vantaggio	Descrizione
Non Invasivo	Non modifichi mai i file core di WordPress
Aggiornamenti Sicuri	Puoi aggiornare WordPress senza perdere le tue modifiche
Modulare	Ogni funzionalità è isolata e indipendente
Estensibile	Altri sviluppatori possono estendere il tuo lavoro