php

Symfony for Beginners – Installation on Windows Machine

What is Symfony? (https://symfony.com)
Symfony is a PHP web application framework and a set of reusable PHP components/libraries. Symfony was published as free software on October 18, 2005 and released under the MIT license.

Alternatives to Symfony are:
– Django (Python)
– Ruby on Rails (Ruby)

Let’s start!!!

WAMP INSTALLATION

1. First we need to install Apache, PHP and MySQL on our Windows Machine.
we can install them separately or installa a PHP development environment, that installs a ready to use environment. There are a lot of software for a dev PHP environment, the most popular are: WAMP XAMPP AMPPS. I will use WAMP.

a. Download WAMP at http://www.wampserver.com/en/#download-wrapper and launch the installer

b. Choose your .exe browser, I will use “C:\Program Files (x86)\Google\Chrome\Application\chrome.exe” because I love the tools for developers of this browser.

Choose yout txt editor, for me is: “C:\Program Files (x86)\Notepad++\notepad++.exe”

c. Open theWindows firewall ports

d. Config the mail() function of PHP

… or leave the default parameters

If installation succeed you will find WAMP options in the notification bar nera your clock.

The WAMP icon will be green: all services running

LMB on WAMP icon:
– Local Host
– phpMyAdmin etc…

RMB on WAMP icon:
– Wamp Settings
– tools
– exit etc…

To avoid conflicts in port 80 with Skype, open Skype> Strumenti> Opzioni> Avanzate> Connessione> uncheck ‘Usa le porte 80 e 443 per le connessioni in ingresso aggiuntive’

WAMP TEST SCRIPT

Now I will test WAMP.

– Click LMB WAMP icon> www directory
– Create here a ‘test’ folder and a test script ‘index.php’


<?php

$name = "Andrew";
echo "My name is " . $name;

?>

– open the browser and digit http://localhost/test/

– You can also LMB WAMP icon> localhost, you will find under ‘Your project’ the ‘test’ folder, but you can not run with a simple click, use the browser at http://localhost/test/ to do it!!!

WAMP phpMyAdmin

– Click LMB WAMP icon> localhost under ‘Tools’ tab phpmyadmin> user ‘root’, pass leave blank

or call with browser http://localhost/phpmyadmin/

SYMFONY INSTALLATION on WAMP with COMPOSER

1. https://getcomposer.org/

2. Download> https://getcomposer.org/Composer-Setup.exe

3. Run as Administrator

4. wamp64/bin/php/php7.0.10/ php.exe

5. Win button> cmd.exe> C:\Users\HAF922\composer and composer will run

START A PROJECT

1. Go to the project folder, example symfonytest> SHIFT+RMB> ‘Apri finestra di comando qui

2. Win button> cmd.exe> composer create-project symfony/framework-standard-edition first_test_symfony
You can use Copy/Paste Win standard function if you want.

3. Download and installation start.
database_host 127.0.0.1: ok is local host
database_port: 3306
database_name: symfony
database_user: root
database_password: 123

secret: 123456

At the end the prompt will have: C:\wamp64\www\symfonytest>cd first_test_symfony

Inside the folder will be the folder structure of my project:
– app
– bin
– src
– tests
– var
– vendor
– web
– composer.json
– LICENSE etc…

Open your broser at: http://localhost/symfonytest/first_test_symfony/web/

Grats!!!

NOTES for Bluehost users at point 3. uses settings similar to the following:

database_driver: pdo_mysql
database_host: localhost
database_port: ~
database_name: (cpanelUsername_databaseName)
database_user: (cpanelUsername_databaseUsername)
database_password: (whatever you picked)
Example:

database_driver: pdo_mysql
database_host: localhost
database_port: ~
database_user: joe1337
database_name: joe1337_sym1
database_password: eHTb7%Pxa9

By |PHP, Symfony, Web Design|Commenti disabilitati su Symfony for Beginners – Installation on Windows Machine

PHP Lezione Itermedia – Oggetti Classi Proprietà Metodi Istanze Costruttori Ereditarietà

PHP Lezione Itermedia – Oggetti Classi Proprietà Metodi Istanze Costruttori Distrutturi Ereditarietà Visibilità Overriding

Concetti intermedi nella programmazione ad oggetti in PHP

Let’s go on!

Creare Oggetti in PHP – Proprietà Dinamiche e Metodi Dinamici

Prima di tutto è necessario capire come funziona la programmazione ad oggetti in PHP.

Un oggetto è del codice che raccoglie delle variabili e le funzioni per processarle.

L’oggetto va dichiarato esplicitamente con la sintassi ‘class’.

Nel gergo della programmazione ad oggetti per essere precisi varibili e funzioni all’interno della classe sono indicati con una terminologia particolare, per essere più precisi:

– le variabili sono definiti proprietà o membri
– le funzioni sono definite metodi

La distinzione di nome è molto importante perchè mentre le normali variabili e funzioni sono componenti libere o di primo livello, le proprietà ed i metodi di una classe appartengono esclusivamente a questa classe (ed eventualmente alle classe che ereditano, come vedremo nelle successive lezioni).

Per richiamare e utilizzare una classe si usano le istanze o oggetti che vengono dichiarate con la sitassi ‘new’ ad esempio.

File1:


class MyClass { // dichiaro l'oggetto
 
        // variabili membro o meglio proprietà
        public $a = 10;
        public $b = 20;
         
        // funzioni o meglio metodi
        public function sayHello() {
                echo "Hello!";
        }
 
}

File2:


// DEVO dichiarare l'istanza, istanza cioè una copia di MyClass
$myClass_1 = new MyClass();
 
// richiama MyClass ed avvia la funzione sayHello() - stampa "Hello!"
$myClass_1->sayHello();
 
// richiama MyClass e preleva la variabile a - stampa 10
echo $myClass_1->a;

Per ogni classe può essere istanziato un numero illimitato di oggetti, ed inviare parametri:


$myClass_2 = new MyClass();
 
// ora la proprietà "a" dell'oggetto $myClass_2 è impostata a 20
$myClass_2->a = 20; // invia un valore ad a
 
// stampa 10
echo $myClass_1->a;

L’oggetto può essere dichiarato con le parentesi se vogliamo usare un costruttore pubblico nella classe
o senza le parentesi se non vogliamo usare un costruttore pubblico nella classe, in questo caso non abbiamo modo di influire sui parametri della classe.


$myClass_1 = new MyClass();
$myClass_2 = new MyClass;

Per richiamare valori variabili dall’interno della classe utilizzeremo la keyword $this che si riferisce sempre all’istanza corrente che stiamo utilizzando, o meglio al valore che è stato inviato dall’istanza.


class MyClass {
 
        // variabili membro o proprietà
        public $a = 10;
        public $b = 20;
         
        // funzioni o metodi
        public function sayHello() {
                echo "Hello! " . $this->a . " " . $this->b;
        }
 
}
 
$myClass_1 = new MyClass();
$myClass_2 = new MyClass();

// stampa "Hello! 10 20", usa i valori indicati all'interno della classe perchè l'istanza non ha inviato nulla
$myClass_1->sayHello();
 
// ora la proprietà "a" dell'oggetto $myClass_2 è impostata a 20
$myClass_2->a = 20;
 
// stampa "Hello! 20 20" perchè usa $this->a cioè il valore 'a' che proviene dall'istanza
$myClass_2->sayHello()

I metodi di una classe riconoscono TUTTE le keyword appartenenti alla classe.

Costruttori

Possiamo decidere quale comportamento deve assumere l’oggetto quando viene creato utilizzando il metoto costruttore o metodo magico con la sintassi __construct (doppio underscore e construct)


class MyClass {
 
        // proprietà
        public $a = 10;
        public $b = 20;
         
        // costruttore o metodo magico
        public function __construct($a, $b) {
                $this->a = $a;
                $this->b = $b;
        }
         
        // metodi
        public function sayHello() {
                echo "Hello! " . $this->a . " " . $this->b;
        }
 
}
 
// creazione delle istanze, notare che i parametri verranno passati al costruttore
$myClass_1 = new MyClass(40, 40);
$myClass_2 = new MyClass("a", "b");

Il funzionamento è il seguente:
1. $myClass_1 = new MyClass(40, 40); è una istanza che invoca MyClass() ed invia 40,10
2. MyClass riceve in public function __construct($a, $b)
3. Che assegna il valore alla variabile in base al valore ricevuto dall’istanza $this->a = $a;
4. sayHello() scrive Hello 40 40

Ovviamente in questo caso, non possiamo omettere i parametri nella fase di creazione delle istanze, altrimenti PHP genererebbe un E_WARNING che ci avvisa della mancata presenza dei parametri richiesti dal costruttore.

Controlli sui Costruttori

Sarà possibile inserire dei controlli alla variabili inviate dall’istanza ad esempio:


class MyClass {
 
        // proprietà
        public $a = 10;
        public $b = 20;
         
        // costruttore
        public function __construct($a, $b) {
                // gli argomenti devono essere interi
                if(!is_int($a) || !is_int($b)) exit("The arguments must be integers!");
                // gli argomenti devono essere minori di 100
                if($a > 100 || $b > 100) exit("The arguments must be less than 100!");
                 
                $this->a = $a;
                $this->b = $b;
                 
                // connessione ad un nostro dataase interno
                connect_to_my_db($this->a, $this->b);
                 
                // operazioni...
        }
         
        // metodi ...
 
}
 
// creazione delle istanze
$myClass_1 = new MyClass(40, 80);               // ok
$myClass_2 = new MyClass("a", "b");             // errore: "The arguments must be integers!"

NOTARE:
if(!is_int($a) || !is_int($b)) exit(“The arguments must be integers!”);
if($a > 100 || $b > 100) exit(“The arguments must be less than 100!”);

Distruttori

Per distruggere gli oggetti si utilizza il metodo magico __destruct (doppio underscore destruct), il metodo __destruct NON ACCETTA argomenti.

Il metodo distruttore viene utilizzato per il clean up delle risorse, ad esempio per la chiusura del database.


class MyClass {
 
        // proprietà
        public $a = 10;
        public $b = 20;
         
        // costruttore
        public function __construct($a, $b) {
                $this->a = $a;
                $this->b = $b;
                 
        }
         
        // distruttore
        public function __destruct() {
                echo "__destruct method called!";
        }
 
}
 
// creazione delle istanze
$myClass_1 = new MyClass("username", "password");
$myClass_2 = new MyClass("username", "password");
$myClass_3 = new MyClass("username", "password");
$myClass_4 = $myClass_3;
 
// distruzione delle istanze
unset($myClass_1);              // stampa "__destruct method called"
$myClass_2 = 0;                 // stampa "__destruct method called"
 
unset($myClass_3);              // non chiama il distruttore, esiste ancora un riferimento all'oggetto $myClass_3

PHP chiama il metodo distruttore solo quando è davvero sicuro che tutti i riferimenti all’oggetto siano stati cancellati oppure quando l’oggetto è distrutto/cancellato manualmente con unset.
Inoltre tutti gli oggetti, come del resto tutte le variabili, vengono distrutti automaticamente da PHP al termine dello script.

Uso di __destruct per la chiusura del database:


class MyClass {
 
        // proprietà
        public $a = 10;
        public $b = 20;
         
        // costruttore
        public function __construct($a, $b) {
                $this->a = $a;
                $this->b = $b;
                 
                // connessione al database interno
                connect_to_my_db($this->a, $this->b);
        }
         
        // distruttore
        public function __destruct() {
                // operazioni di clean up...
                // chiusura del database e rilascio delle risorse
                free_my_db();
        }
         
        // metodi
        public function sayHello() {
                echo "Hello! " . $this->a . " " . $this->b;
        }
 
}
 
// creazione delle istanze
$myClass_1 = new MyClass("username", "password");

Proprietà Statiche

Le proprietà statiche si dichiarano attraverso la parola chiave (“static”)

Le proprietà statiche non appartengono a nessuna istanza in particolare, quindi non possono essere richiamate con l’operatore di deferenziamento (“->”)

Sono di fatto componenti statiche di proprietà della classe stessa e vengono richiamate con l’operatore di risoluzione (“::”) oppure con la keyword self.


class MyClass {
 
        // proprietà statiche
        public static $apples = 10;
        public static $pineapples = 20;
 
}
 
// stampa 10
echo MyClass::$apples;
 
// stampa 20
echo MyClass::$pineapples;

Le proprietà statiche possono cambiare il loro valore:


class MyClass {
 
        // proprietà statiche
        public static $instances = 0;
        public $idKey = false;
         
        // costruttore
        public function __construct() {
                $this->idKey = ++self::$instances;
                echo "This is the #" . $this->idKey 
		. " instance of the class MyClass.Instances created: " . $this->idKey;
        }
         
        // distruttore
        public function __destruct() {
                echo "Instance #" . $this->idKey . " deleted.";
        }
 
}
 
// stampa "This is the #1 instance of the class MyClass. Instances created: 1"
$myClass_1 = new MyClass();
 
// stampa "This is the #2 instance of the class MyClass. Instances created: 2"
$myClass_2 = new MyClass();
 
// stampa "This is the #3 instance of the class MyClass. Instances created: 3"
$myClass_3 = new MyClass();
 
// al termine dello script: "Instance #1 deleted.", "Instance #2 deleted.", "Instance #3 deleted."

Metodi Statici

I metodi statici sono dati di classe che non appartengono a nessuna istanza in particolare. Anch’essi devono essere preceduti dalla keyword ‘static’ e richiamati con ::


class MyClass {
 
        // metodi statici
        public static function sayHello() {
                echo "Hello!";
        }
         
        public static function sayHelloAgain() {
                self::sayHello(); // la sintassi è self:: per richiamare il metodo statico dall'interno della classe
                echo " Again!";
        }
 
}
 
// stampa "Hello!"
MyClass::sayHello();
 
// stampa "Hello! Again!"
MyClass::sayHelloAgain();

Eredietarietà

Tramite l’ereditarietà (inheritance), una classe (sottoclasse o classe figlia), può ereditare sia i metodi che le proprietà da un’altra classe (superclasse o classe padre). Per estendere una classe si utilizza la keyword ‘extends’


class MyClass {
 
        const A = 10;
         
        // proprietà
        public $a = 10;
         
        // metodi
        public function sayHello() {
                echo "Hello!";
        }
 
}
 
class AnotherClass extends MyClass {
         
        // proprietà
        public $b = 10;
 
}
 
$myClass = new MyClass();
 
// stampa (10)
echo $myClass->a;
 
// modifica
$myClass->a = 20;
 
// chiamata ("Hello!")
$myClass->sayHello();
 
$anotherClass = new AnotherClass();
 
// stampa (10)
$anotherClass->a; // notare che non è stata influenzata dalla modifica =20
 
// chiamata ("Hello!")
$anotherClass->sayHello();

Public Protected Private

Tramite l’utilizzo delle keyword – public – protected – private – (indicatori di visibilità) possiamo definire la visibilità delle proprietà e dei metodi di una classe, in particolare

public
– interno della classe stessa: accessibile/modificabile
– esterno della classe: accessibile/modificabile
– interno classe che la ereditano (extends): accessibile/modificabile

protected
– interno della classe stessa: accessibile/modificabile
– esterno della classe: non accessibile (Fatal Error)
– interno classe che la ereditano (extends): accessibile/modificabile

private
– interno della classe stessa: accessibile/modificabile
– esterno della classe: non accessibile (Fatal Error)
– interno classe che la ereditano (extends): non accessibile


class MyClass {
         
        // proprietà
        protected $a = 10;
         
        // metodi
        protected function sayHello() {
                echo "Hello!";
        }
 
}
 
class AnotherClass extends MyClass {
 
        public function sayHelloAgain() {
                $this->sayHello();
        }
 
}
 
$anotherClass = new AnotherClass();
 
// stampa "Hello!"
$anotherClass->sayHelloAgain();

//  Fatal Error
echo $myClass->a;
 
// Fatal Error
$myClass->sayHello();

// Fatal error
$anotherClass->sayHello();

// Fatal Error
$anotherClass->sayHelloAgain();

Overriding o Ridefinizione

Con l’Overriding o ridefinizione estendiamo una classe al fine di sovrascrivere il vecchio metodo con uno nuovo:


class A {
        public function sayHello() {
                echo "Hello!";        
        }
}
 
class B extends A {
        public function sayHello() {
                echo "Ciao Ciao!";    
        }
}
 
$b = new B();
 
// stampa "Ciao Ciao!"
$b->sayHello(); // il metodo con lo stesso nome più nuovo prende il posto di quello vecchio.

Overriding – parent –

Utilizzando la keyword – parent:: – possiamo sommare il risultato di due metodi con lo stesso nome


class A {
 
        public function sayHello() {
                echo "Hello!";        
        }
 
}
 
class B extends A {
 
        public function sayHello() {
                parent::sayHello();
                echo "Ciao Ciao!";    
        }
 
}
 
$b = new B();
 
// stampa "Hello! Ciao Ciao!"
$b->sayHello(); // il risultato è la somma dei due metodi

Un esempio di parent sul costruttore


class A {
        public function __construct($a, $b, $c, $d) {
                $this->a = $a;
                $this->b = $b;
                $this->c = $c;
                $this->d = $d;
        }
         
        // metodi...
 
}
 
class B extends A {
        public function __construct($a, $b, $c, $d, $e) {
                parent::__construct($a, $b, $c, $d);
                $this->e = $e;
        }
         
        // metodi...
 
}
 
$b = new B(10, 20, 30, 40, 50);
 
echo $b->a;  // stampa 10
echo $b->b;  // stampa 20
echo $b->c;  // stampa 30
echo $b->d;  // stampa 40
echo $b->e;  // stampa 50

Come funziona?
1. Creo un’istanza basata sulla classe B ‘$b = new B(10, 20, 30, 40, 50);’ ed inviando dei valori
2. ‘class B extends A’ invoca il costruttore della classe padre ‘parent::__construct($a, $b, $c, $d);’
3. La classe parent assegna con il suo costruttore i valori ricevuti alle variabili ‘function __construct($a, $b, $c, $d){$this->a = $a;’
4. echo visualizza i valori delle variabili

Impedire Overriding di Metodi e Classi – final –

Per garantire stabilità alle nostre gerarchie si può impedire l’Overridind dei metodì crucialiper il funzionamento della nostra applicazione.
Ad esempio potremo impedire la ridefinizione della classe per il collegamento al database o il parsing dei documenti.
Per fare questo utilizzaremo la keyword – final –

Per i metodi:


class MyClass {
        final public function connect_to_my_db() {
                // implementazione...
        }
         
        final public function parse_my_xml_doc() {
                // implementazione...
        }
         
        final public function sayHello() {
                echo "Hello!";
        }
}
 
$myClass = new MyClass();
 
// stampa "Hello!"
$myClass->sayHello();

// Fatal Error perchè sayHello() è stata dichiarata - final -
// NON POSSO FARE OVERRIDING
class AnotherClass extends MyClass {
        public function sayHello() {
                echo "Hello!";
        }
 
}

Per le classi:


final class MyClass {
        // implementazione...
} 

// Fatal Error: lass AnotherClass may not inherit from final class (MyClass)
lass AnotherClass extends MyClass {
        // implementazione...
}

Il mio sito ufficiale:
www.lucedigitale.com

Bibligrafia:
www.html.it/pag/18341/creare-le-classi/
www.html.it/pag/18353/impedire-loverriding-final/

By |PHP, Web Design|Commenti disabilitati su PHP Lezione Itermedia – Oggetti Classi Proprietà Metodi Istanze Costruttori Ereditarietà

PHP Development – Easy PHP – NetBeans IDE for noobs

What is and IDE?

To develop HTML and CSS you can use an advance notepad as NotePad++ (http://notepad-plus-plus.org/).
A tool like that is very useful for:
– Syntax Highlighting and Syntax Folding
– Auto-completion: Word completion, Function completion and Function parameters hint
– Multi-View

To edit simple PHP code you can use NotePad++ but if you want develop an application with variables and classes you will need an IDE environment. An integrated development environment (IDE) or interactive development environment is a software application that provides comprehensive facilities to computer programmers for software development.
An IDE normally consists of:
– Syntax Highlighting and Syntax Folding
– Auto-completion: Word completion, Function completion and Function parameters hint
– Multi-View
– Build Automation Tool
– Debugger
– Ready to use code for graphic elements as windows, slides, buttons.
– Project Support to organize files better

Debugger help you to find evil bugs in less time.

Today we will try NetBeans IDE (https://netbeans.org/).
NetBeans IDE is free and by Oracle.

What is a WAMP?

A WAMP (Windows web development environment) allows you to create web applications with Apache, PHP and a MySQL database without installing them in your system. It is a like a magic standalone box :)

I like to use EasyPHP(http://www.easyphp.org/).

Install and Run EasyPHP

1. Go to http://www.easyphp.org/ download ‘E Development Server’ and install

2. Go to your installation folder, usually Programmi(x86)> EasyPHP> data> localweb> www> create the folder ‘test-net-beans’

3. If you have Skype running, drop it because it uses the same port of EasyPHP

4. Run EasyPHP

5. Barra di Windows> icone nascoste> RMB over EasyPHP> Administrator to see versions of Apache PHP and MYSQL

6. Barra di Windows> icone nascoste> RMB over EasyPHP> Local Web> www, to see the root folder of your website

Install and Run NetBean IDE

1. Download the package here http://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.html
This package includes NetBeans 8.0.2 + JDK, one installation, two packages!
Lanch the .exe and install

2. Open NetBeans IDE> MAIN TOP MENU> Tools> Plugins> ‘Available Plugins’ tab> check PHP> ‘Install’ button, then restat IDE

New Project – Hello World!

0. Run NetBeans IDE

1. MAIN TOP MENU> File> New project> PHP Application

2.
Project Name: TestNetBeans
Sources Folder: usually Programmi(x86)> EasyPHP> data> localweb> www> test-net-beans
PHP Version: the same setup in barra di Windows> Icone nascoste> RMB Easy PHP> Administration

3.
Run As: Local Web Site
Project URL: http://localhost/www/test-netbeans/

4. PHP Frameworks: leave blank

NOTICE: inside Programmi(x86)> EasyPHP> data> localweb> www> create the folder ‘test-net-beans’ now there is the folder /nbproject

5. NetBeans> MAIN TOP MENU> File> New File> PHP> PHP File (empty php file)

6.
File Name: index
Folder: Browse the root folder or wherever you want, ‘Finish’, good! We have our first index.php! Congrats!

7. Write inside index.php:


<?php
/* 
 * My first index file
 */
echo "Hello World!";
?>

8. MAIN TOOLBAR> Play!

PHP Application with Existing Sources

0. Run NetBeans IDE

1. MAIN TOP MENU> File> New project> PHP Application with Existing Sources

2.
Project Name: TestNetBeans
Sources Folder: usually Programmi(x86)> EasyPHP> data> localweb> www> my-old-project
Project Name: my-old-project
PHP Version: the same of EasyPHP

3.
Run As: Local Web Site
Project URL: http://127.0.0.1/www/my-old-project/
NOTE: you can modify later at File> Project Properties> Run Configuration> Project URL
Index Folder: index.php or other

Debug

1. NetBeans> MAIN TOP TOOLBAR> Debug Project, it will open a page like this: ‘http://127.0.0.1/www/my-website-folder/index.php?XDEBUG_SESSION_START=netbeans-xdebug

2. MAIN TOOL BAR> ‘Step Into'(F7) to debug step by step

Resume

The combination of tools is simple:

1. Easy PHP acts like a webserver, run Apache, PHP and MySQL in a sandbox and hosts the web site inder /www/mysite folder
2. NetBeans create a project file inside /www/mysite/nbproject and manages/edits .php files inside /www/mysite folder

NeBeans IDE edit -> | /www folder of EasyPHP WAMP |

By |PHP, Web Design|Commenti disabilitati su PHP Development – Easy PHP – NetBeans IDE for noobs

PHP – Email Injection protection

PHP – Email Injection protection

A malicious spammer could use Email Injection to send large numbers of messages anonymously.

When a form is added to a Web page that submits data to a Web application, a malicious user may exploit the MIME format to append additional information to the message being sent, such as a new list of recipients or a completely different message body.

Because the MIME format uses a carriage return to delimit the information in a message, and only the raw message determines its eventual destination, adding carriage returns to submitted form data can allow a simple guestbook to be used to send thousands of messages at once.

The best way to stop e-mail injections is to validate the input.

HTML form:


<html>
<body>
<?php
function spamcheck($field)
  {
  // Sanitize e-mail address
  $field=filter_var($field, FILTER_SANITIZE_EMAIL);
  // Validate e-mail address
  if(filter_var($field, FILTER_VALIDATE_EMAIL))
    {
    return TRUE;
    }
  else
    {
    return FALSE;
    }
  }
?>

<h2>Feedback Form</h2>
<?php
// display form if user has not clicked submit
if (!isset($_POST["submit"]))
  {
  ?>
  <form method="post" action="<?php echo $_SERVER["PHP_SELF"];?>">
  From: <input type="text" name="from"><br>
  Subject: <input type="text" name="subject"><br>
  Message: <textarea rows="10" cols="40" name="message"></textarea><br>
  <input type="submit" name="submit" value="Submit Feedback">
  </form>
  <?php 
  }
else
  // the user has submitted the form
  {
  // Check if the "from" input field is filled out
  if (isset($_POST["from"]))
    {
    // Check if "from" email address is valid
    $mailcheck = spamcheck($_POST["from"]);
    if ($mailcheck==FALSE)
      {
      echo "Invalid input";
      }
    else
      {
      $from = $_POST["from"]; // sender
      $subject = $_POST["subject"];
      $message = $_POST["message"];
      // message lines should not exceed 70 characters (PHP rule), so wrap it
      $message = wordwrap($message, 70);
      // send mail
      mail("webmaster@example.com",$subject,$message,"From: $from\n");
      echo "Thank you for sending us feedback";
      }
    }
  }
?>
</body>
</html>

How does it work?

1. Get the input data from the HTML form:

 <form method="post" action="<?php echo $_SERVER["PHP_SELF"];?>">
  From: <input type="text" name="from"><br>
  Subject: <input type="text" name="subject"><br>
  Message: <textarea rows="10" cols="40" name="message"></textarea><br>
  <input type="submit" name="submit" value="Submit Feedback">
 </form>

2. The php script send form data to itself:

<?php echo $_SERVER["PHP_SELF"];?>

3. Check if the “from” input field is filled out

if (isset($_POST["from"]))

4.Send the “from” value to the function spamcheck()

$mailcheck = spamcheck($_POST["from"]);

5. spamcheck() function:
a. The FILTER_SANITIZE_EMAIL filter removes all illegal e-mail characters from a string
b. The FILTER_VALIDATE_EMAIL filter validates value as an e-mail address
c. It wll return TRUE if it is all ok!

function spamcheck($field)
  {
  // Sanitize e-mail address
  $field=filter_var($field, FILTER_SANITIZE_EMAIL);
  // Validate e-mail address
  if(filter_var($field, FILTER_VALIDATE_EMAIL))
    {
    return TRUE;
    }
  else
    {
    return FALSE;
    }
  }

6. If it is FALSE It will print the message “Invalid input”

$mailcheck = spamcheck($_POST["from"]);
    if ($mailcheck==FALSE)
      {
      echo "Invalid input";
      }

7. If it is TRUE It will send the message and will print “Thank you for sending us feedback”

else
      {
      $from = $_POST["from"]; // sender
      $subject = $_POST["subject"];
      $message = $_POST["message"];
      // message lines should not exceed 70 characters (PHP rule), so wrap it
      $message = wordwrap($message, 70);
      // send mail
      mail("myemail@lucedigitale.com",$subject,$message,"From: $from\n");
      echo "Email sent successfully";
      }
By |Web Design, WordPress|Commenti disabilitati su PHP – Email Injection protection

WordPress – Creare un Widget

Wordpress – Creare un Widget

1. Creare una Site Specific PlugIn

Creare il file php ‘yoursitename-plugin.php’ in:
blog/wp-content/plugins/yoursitename-plugin/yoursitename-plugin.php

Il codice:


<?php
/*
Plugin Name: Luce Digitale - Widget Sample 
Description: Un esempio di Widget personalizzato.
*/

/* Start Adding Functions Below this Line */

// Creating the widget 
class wpb_widget extends WP_Widget {

function __construct() {
parent::__construct(
// Base ID of your widget
'wpb_widget', 

// Widget name will appear in UI
__('Sample Luce Digitale Widget', 'wpb_widget_domain'), 

// Widget description
array( 'description' => __( 'Sample Luce Digitale widget', 'wpb_widget_domain' ), ) 
);
}

// Creating widget front-end
// This is where the action happens
public function widget( $args, $instance ) {
$title = apply_filters( 'widget_title', $instance['title'] );
// before and after widget arguments are defined by themes
echo $args['before_widget'];
if ( ! empty( $title ) )
echo $args['before_title'] . $title . $args['after_title'];

// This is where you run the code and display the output
echo __( 'Hello, World!', 'wpb_widget_domain' );
echo $args['after_widget'];
}
		
// Widget Backend 
public function form( $instance ) {
if ( isset( $instance[ 'title' ] ) ) {
$title = $instance[ 'title' ];
}
else {
$title = __( 'New title', 'wpb_widget_domain' );
}
// Widget admin form
?>
<p>
<label for="<?php echo $this->get_field_id( 'title' ); ?>"><?php _e( 'Title:' ); ?></label> 
<input class="widefat" id="<?php echo $this->get_field_id( 'title' ); ?>" name="<?php echo $this->get_field_name( 'title' ); ?>" type="text" value="<?php echo esc_attr( $title ); ?>" />
</p>
<?php 
}
	
// Updating widget replacing old instances with new
public function update( $new_instance, $old_instance ) {
$instance = array();
$instance['title'] = ( ! empty( $new_instance['title'] ) ) ? strip_tags( $new_instance['title'] ) : '';
return $instance;
}
} // Class wpb_widget ends here

// Register and load the widget
function wpb_load_widget() {
	register_widget( 'wpb_widget' );
}
add_action( 'widgets_init', 'wpb_load_widget' );
 
/* Stop Adding Functions Below this Line */
?>

Attivare:

COLONNA SINISTRA> PlugIns> ‘Luce Digitale – Widget Sample’> Activate

COLONNA SINISTRA> Aspetto> Widgets> ‘Sample Luce Digitale Widget’ inserire il Widget nell’interfaccia

Warning Messages

Dopo l’attivazione della plugin può essere restituito il seguente errore:

The plugin generated xxx characters of unexpected output during activation

Questo succede se si lasciano delle righe bianche in testa al file php, prima del tag ‘

By |Web Design, WordPress|Commenti disabilitati su WordPress – Creare un Widget