Ecco uno scenario tipico per questo errore: una form per inviare una foto dove si vuole fare attendere l’utente che finisca l’upload dandogli la sensazione, tramite una gif animata, che la pagina web stia lavorando.

<form onSubmit="gif()" name="myform" action="#" method="post" enctype="multipart/form-data">
<p id="wait">
<img id="WaitImage" src="images/loadingAnimation.gif"/><br />
<strong>È in corso l'invio ...<br />
L'operazione potrebbe richiedere qualche minuto, attendi senza chiudere questa finestra.
</strong>
</p>
</form>


Visto che su IE la gif che era nascosta, quando invio la form smette di essere animata, bisogna trovare un modo per farla ripartire.

Tutto si può fare dando l’impressione ad IE di aver modificato l’immagine con Javascript un tempo successivo all’invio della form, tramite questa istruzione:

setTimeout('document.getElementById("WaitImage").src = "images/loadingAnimation.gif"', 200);



<script type="text/javascript">
function gif()
{
if (document.forms["myform"]["file"].value != "")
{
document.getElementById(\'bottone_carica\').style.display = \'none\';
document.getElementById(\'wait\').style.display = \'block\';
setTimeout(\'document.getElementById("WaitImage").src = "images/loadingAnimation.gif"\', 200);
}
}
</script>


Così la gif bloccata ripartirà a eseguire la sua animazione.


'<img src="immagine.jpg?t='.time().'"/>'


Vediamo come sviluppare un modulo che aggiunga il tipo di contenuto libro.

Creiamo la cartella node_book che andremo a mettere nella cartella modules del nostro sito.
Dentro questa cartella mettiamo il file node_book.info con le specifiche del nodo:

; $Id$
name = node book
description = "nodo libro"
core = 6.x


e il file node_book.module con il codice vero e proprio.

Ecco i vari hook che si devono implementare:
Hook menu

function node_book_menu()
{
$items[] = array( 'path' => 'node_book', 'callback' => 'node_book_page', 'access' => true, 'type' => MENU_CALLBACK );
return $items;
}


hook perm

function node_book_perm()
{
return array('create book node', 'edit own book nodes');
}

hook access
function node_book_access($op, $node, $account) {
if ($op == 'create') {
// Only users with permission to do so may create this node type.
return user_access('create nameofnodetype', $account);
}
// Users who create a node may edit or delete it later, assuming they have the
// necessary permissions.
if ($op == 'update' || $op == 'delete') {
if (user_access('edit own nameofnodetype', $account) && ($account->uid == $node->uid)) {
return TRUE;
}
}
}

hook help
function node_book_help($path, $arg) {
switch ($path) {
case 'admin/help#block':
return '

'. t('Blocks are boxes of content that may be rendered into certain regions of your web pages, for example, into sidebars. Blocks are usually generated automatically by modules (e.g., Recent Forum Topics), but administrators can also define custom blocks.') .'

', array('@throttle' => url('admin/settings/throttle')));
}
}
Ora passiamo agli hook che implementano veramente il nostro modulo:
hook form

function node_book_form(&$node) {
$type = node_get_types('type', $node);
if ($type->has_title) {
$form['title'] = array(
'#type' => 'textfield',
'#title' => check_plain($type->title_label),
'#required' => TRUE,
'#default_value' => $node->title,
'#weight' => -5
);
}
if ($type->has_body) {
// In Drupal 6, we can use node_body_field() to get the body and filter
// elements. This replaces the old textarea + filter_form() method of
// setting this up. It will also ensure the teaser splitter gets set up
// properly.
$form['body_field'] = node_body_field($node, $type->body_label, $type->min_word_count);
}
// NOTE in node_example there is some addition code here not needed for this simple node-type
// Now we define the form elements specific to our node type.
$form['editor'] = array(
'#type' => 'textfield',
'#title' => t('Editore'),
'#default_value' => isset($node->editor) ? $node->editor : '',
);
$form['book_author'] = array(
'#type' => 'textfield',
'#title' => t('Autore'),
'#default_value' => isset($node->book_author) ? $node->book_author : '',
);
$form['place'] = array(
'#type' => 'textfield',
'#title' => t('Luogo'),
'#default_value' => isset($node->place) ? $node->place : '',
);
$form['year'] = array(
'#type' => 'textfield',
'#title' => t('Anno'),
'#default_value' => isset($node->year) ? $node->year : '',
);
$form['book_type'] = array(
'#type' => 'textfield',
'#title' => t('Tipo'),
'#default_value' => isset($node->book_type) ? $node->book_type : '',
);
$form['magazine'] = array(
'#type' => 'textfield',
'#title' => t('Rivista'),
'#default_value' => isset($node->magazine) ? $node->magazine : '',
);
return $form;
}

hook insert
/**
* Implementation of hook_insert().
*
* As a new node is being inserted into the database, we need to do our own
* database inserts.
*/
function node_book_insert($node) {
db_query("INSERT INTO {node_book} (vid, nid, editor, book_author, place, year, book_type, magazine) VALUES (%d, %d, '%s', '%s', '%s', '%s', '%s', '%s')", $node->vid, $node->nid,$node->editor,$node->book_author,$node->place,$node->year,$node->book_type,$node->magazine);
}

hook update
/**
* Implementation of hook_update().
*
* As an existing node is being updated in the database, we need to do our own
* database updates.
*/
function node_book_update($node) {
// if this is a new node or we're adding a new revision,
if ($node->revision) {
node_book_insert($node);
}
else {
db_query("UPDATE {node_book} SET editor='%s', book_author='%s', place='%s', year='%s', book_type='%s', magazine='%s' WHERE vid = %d", $node->editor, $node->book_author, $node->place, $node->year, $node->book_type, $node->magazine, $node->vid);
}
}


hook nodeapi
/**
* Implementation of hook_nodeapi().
*
* When a node revision is deleted, we need to remove the corresponding record
* from our table. The only way to handle revision deletion is by implementing
* hook_nodeapi().
*/
function node_book_nodeapi(&$node, $op, $teaser, $page) {
switch ($op) {
case 'delete revision':
// Notice that we're matching a single revision based on the node's vid.
db_query('DELETE FROM {node_book} WHERE vid = %d', $node->vid);
break;
}
}

hook_delete
/**
* Implementation of hook_delete().
*
* When a node is deleted, we need to remove all related records from out table.
*/
function node_book_delete($node) {
// Notice that we’re matching all revision, by using the node’s nid.
db_query(’DELETE FROM {node_book} WHERE nid = %d’, $node->nid);
}

hook load
/**
* Implementation of hook_load().
*
* Now that we've defined how to manage the node data in the database, we
* need to tell Drupal how to get the node back out. This hook is called
* every time a node is loaded, and allows us to do some loading of our own.
*/
function node_book_load($node) {
$additions = db_fetch_object(db_query('SELECT editor,book_author,place,year,book_type,magazine FROM {node_book} WHERE vid = %d', $node->vid));
return $additions;
}


hook view
/**
* Implementation of hook_view().
*
* This is a typical implementation that simply runs the node text through
* the output filters.
*/
function node_book_view($node, $teaser = FALSE, $page = FALSE) {
$node = node_prepare($node, $page);
$node->content['myfield'] = array(
'#value' => 'Editore: '.$node->editor.'<br />'.'Autore: '.$node->book_author.'<br >'.'Luogo: '.$node->place.'<br >'.'Anno: '.$node->year.'<br >'.'Tipologia: '.$node->book_type.'<br >',
'#weight' => 1,
);
return $node;
}


Ora manca solo il DB, ecco la tabella per i campi in più del nostro nodo
CREATE TABLE node_book (
vid int(10) unsigned NOT NULL default ‘0′,
nid int(10) unsigned NOT NULL default ‘0′,
editor varchar(255) NOT NULL default ”,
book_author varchar(255) NOT NULL default ”,
place varchar(255),
year varchar(255),
book_type varchar(255),
magazine varchar(255),
PRIMARY KEY (vid, nid),
KEY `node_type_book_nid` (nid)
)

Dopo aver creato la tabella e attivato il modulo avrete un nuovo tipo di contenuto disponibile.

Linux:

find ./ -name .svn -exec rm -rf {} +


Ho deciso di studiarlo un po’:

Creo un Database di prova:

DROP TABLE IF EXISTS first_table;


--CREATE TABLE first_table (
--id INT(10) NOT NULL AUTO_INCREMENT,
--name VARCHAR(255) NOT NULL,
--surname VARCHAR(255) NOT NULL,
--PRIMARY KEY (id)
--) TYPE=MyISAM;


CREATE TABLE first_table (
id INT(10) NOT NULL AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
surname VARCHAR(255) NOT NULL,
PRIMARY KEY (id)
) TYPE=innoDB;


INSERT INTO first_table (name,surname) VALUES ('matteo','magni');
INSERT INTO first_table (name,surname) VALUES ('john','starks');
INSERT INTO first_table (name,surname) VALUES ('michael','jordan');
INSERT INTO first_table (name,surname) VALUES ('kobe','bryant');
INSERT INTO first_table (name,surname) VALUES ('earvin','johnson');
INSERT INTO first_table (name,surname) VALUES ('larry','bird');
INSERT INTO first_table (name,surname) VALUES ('patrick','ewing');
INSERT INTO first_table (name,surname) VALUES ('reggie','miller');
INSERT INTO first_table (name,surname) VALUES ('ron','harper');
INSERT INTO first_table (name,surname) VALUES ('anfernee','hardaway');
INSERT INTO first_table (name,surname) VALUES ('tim','hardaway');
INSERT INTO first_table (name,surname) VALUES ('mitch','richmond');
INSERT INTO first_table (name,surname) VALUES ('jason','williams');
INSERT INTO first_table (name,surname) VALUES ('allen','iverson');
INSERT INTO first_table (name,surname) VALUES ('dwayne','wade');


Lo importo così dopo aver creato il DB pdo

mysql -p -D pdo < pdo.sql

Per le prove utilizzerò sia la versione con tabella MyISAM che quella con tabella InnoDB, la differenza è che per la prima non sono disponibili le transazioni.

Usiamo le eccezioni per connetterci al DB

//USO le eccezioni
$string_dsn = 'mysql:host=localhost;dbname=pdo'; // mysql
$string_username = 'user';
$string_password = 'password';
try {
$mypdo = new PDO($string_dsn, $string_username, $string_password);
}
catch(PDOException $e) {
echo 'Errore di connessione: '.$e->getMessage();
}


Query fatta con errore, mi restituisce il numero dell’errore:

$mypdo->exec('SELECT * FROM SELECT'); // errore generato appositamente
echo 'Errore N: '.$mypdo->errorCode();


Se la uso così è molto utile, mando io il messaggio che voglio:

if($mypdo->errorCode() !== '' || !$mypdo->exec('SELECT * FROM SELECT'))
echo 'errore nella query SELECT * FROM SELECT';


Così mi ritorna un array di tre elementi con le notizie sull’errore:

var_dump($mypdo->errorInfo());
//array di tre elementi
if(count($mypdo->errorInfo()) == 1) // ... tutto ok
if(count($mypdo->errorInfo()) > 1) { // ... ci sono errori
$errorinfo = $mypdo->errorInfo();
echo $errorinfo[2]; // stringa con l' errore
}


QUERY semplice senza preparare niente,
Mi ritorna i dati accessibili sia con il numero della colonna (partendo da 0) che con il nome della colonna
Query senza parametri aggiuntivi per stabilire che Fetch usare:


foreach($mypdo->query('SELECT * FROM first_table') as $row)
{
echo '--------------<br />';
echo '1: '.$row[0].' - 2: '.$row[1].'<br />';
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}

mi ritorna i dati accessibili sia con il numero della colonna (partendo da 0) che con il nome della colonna.

Esplicito il tipo di Fetch con il parametro PDO_FETCH_*
PDo::FETCH_BOTH #usatelo come mysql fetch_array, risultato duplicato, quello di default

foreach($mypdo->query('SELECT * FROM first_table', PDO::FETCH_BOTH) as $row)
{
echo '--------------<br />';
echo '1: '.$row[0].' - 2: '.$row[1].'<br />';
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}


PDO::FETCH_ASSOC #usatelo come mysql_fetch_assoc

foreach($mypdo->query('SELECT * FROM first_table', PDO::FETCH_ASSOC) as $row)
{
echo '--------------<br />';
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}


PDO::FETCH_NUM #analogo a mysql_fetch_row

foreach($mypdo->query('SELECT * FROM first_table', PDO::FETCH_NUM) as $row)
{
echo '--------------<br/>';
echo '1: '.$row[0].' - 2: '.$row[1].'<br/>';
}


PDO::FETCH_OBJ #ritorna un oggetto con le proprieta’ che hanno il nome dei campi

foreach($mypdo->query('SELECT * FROM first_table', PDO::FETCH_OBJ) as $row)
{
echo '--------------<br />';
echo 'id->'.$row->id.' - name-> '.$row->name.'<br />';
}


PDO::FETCH_LAZY #combina *_BOTH e *_OBJ

foreach($mypdo->query('SELECT * FROM first_table', PDO::FETCH_LAZY) as $row)
{
echo '--------------<br />';
echo '1: '.$row[0].' - 2: '.$row[1].'<br />';
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
echo 'id->'.$row->id.' - name-> '.$row->name.'<br />';
}


PDO::FETCH_BOUND #Lo vediamo con bindColumn,
restituiti come attributi alle variabili PHP

Per Evitare problemi con DB case sensitive e non case sensitive
Setto che i nomi delle colonne siano restituiti sempre minuscoli

$mypdo->setAttribute(PDO::CASE_LOWER);
/*
* Psso usare anche
* PDO::CASE_UPPER
* PDO::CASE_NATURAL come sono fornite dal driver, metodo di default
*/

oppure si usa sempre FETCH_NUM

Utilizzo delle Transazioni

inizio la transazione

Su Mysql devo usare tabelle InnoDB perchè MyIsam non supportano le transazioni

Però…
The following example begins a transaction and issues two statements that
modify the database before rolling back the changes.
On MySQL, however, the DROP TABLE statement automatically commits the
transaction so that none of the changes in the transaction are rolled back.

Quindi niente drop per una transazione.

$mypdo->beginTransaction();
$mypdo->exec('DROP TABLE first_table');
$mypdo->rollBack(); // la tabella mytable rimarra' invariata :-)


come detto su MySQL la cancella lo stesso.


$mypdo->beginTransaction();
$mypdo->exec("INSERT INTO first_table (name,surname) VALUES ('gianni','morandi')");
$mypdo->rollBack(); // la tabella mytable rimarra' invariata :-)



$mypdo->beginTransaction();
$mypdo->exec("INSERT INTO first_table (name,surname) VALUES ('gianni','morandi')");
$mypdo->commit(); // la tabella mytable rimarra' invariata :-)

mi inserisce il nuovo valore.

Prepared Statement

Metodo Fetch
Metodo implementato nello statement che è in grado di spostare il cursore dei risultati di una query in un ciclo.
Gli posso passare i parametri come a query.
/*
* PDO::FETCH_ASSOC, PDO::FETCH_BOTH, PDO::FETCH_BOUND, PDO::FETCH_LAZY,
* PDO::FETCH_OBJ, PDO::FETCH_NUM
*/

$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare('UPDATE first_table SET name = "pippo" WHERE id = 17');
// eseguo la query
$stpdo->execute();
$mypdo->commit();
echo 'SELECT';
$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare('SELECT * FROM first_table');
// eseguo la query
$stpdo->execute();
//stampo a video il contenuto dell'array che mi crea fetch
while ($row=$stpdo->fetch())
{
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}
$mypdo->commit();


La potenza prepare e execute
Potenza del metodo prepare

$mypdo->beginTransaction();
$stpdo = $mypdo->prepare('UPDATE first_table SET name = ? WHERE id = ?');
//i punti interrogativi saranno sostituiti da execute
$stpdo->execute(array('gianni', 17));
$mypdo->commit();
echo 'SELECT';
$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare('SELECT * FROM first_table');
// eseguo la query
$stpdo->execute();
//stampo a video il contenuto dell'array che mi crea fetch
while ($row=$stpdo->fetch())
{
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}
$mypdo->commit();

Posso preparare la query una volta e fare poi i vari inserimenti.
potenza prepare e execute ancora

$mypdo->beginTransaction();
$stpdo = $mypdo->prepare('UPDATE first_table SET name = :name WHERE id = :id');
//i punti interrogativi non sempre sono chiari, così lo è di più
$stpdo->execute(array(':name'=>'marcello',':id'=>17));
$mypdo->commit();
echo 'SELECT';
$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare('SELECT * FROM first_table');
// eseguo la query
$stpdo->execute();
//stampo a video il contenuto dell'array che mi crea fetch
while ($row=$stpdo->fetch())
{
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}
$mypdo->commit();


Metodo fetchAll
ritorna un array le righe del resultset

$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare('SELECT * FROM first_table');
// eseguo la query
$stpdo->execute();
$row=$stpdo->fetchAll();
//stampo a video il contenuto dell'array che mi crea fetch
var_dump($row);
$mypdo->commit();


Metodo fetchAll

$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare('SELECT * FROM first_table');
// eseguo la query
$stpdo->execute();
$row=$stpdo->fetchAll(PDO::FETCH_OBJ);
//così ho un array di oggetti
//stampo a video il contenuto dell'array che mi crea fetch
var_dump($row);
$mypdo->commit();


Metodi bind

bindParam

$id=10;
$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare("SELECT * FROM first_table WHERE id = ? ");
$stpdo->bindParam(1,$id, PDO::PARAM_INT);
$stpdo->execute();
while ($row=$stpdo->fetch())
{
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}
$mypdo->commit();

Oppure:

$id=10;
$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare("SELECT * FROM first_table WHERE id = :id ");
$stpdo->bindParam(':id',$id, PDO::PARAM_INT);
$stpdo->execute();
while ($row=$stpdo->fetch())
{
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}
$id=13;
$stpdo->bindParam(':id',$id, PDO::PARAM_INT);
$stpdo->execute();
while ($row=$stpdo->fetch())
{
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}
$mypdo->commit();

Così ho preparato la query una volta sola, ed ho legato :id al valore della variabile $id.

bindValue

$id=10;
$mypdo->beginTransaction();
$stpdo = $mypdo->prepare('SELECT * FROM first_table WHERE id < ? ');
$stpdo->bindValue(1, $id, PDO::PARAM_INT);
$stpdo->execute();
while ($row=$stpdo->fetch())
{
echo 'id: '.$row['id'].' - name: '.$row['name'].'<br />';
}
$mypdo->commit();


bindColumn

$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare("SELECT * FROM first_table ");
$stpdo->bindColumn(1,$id);
$stpdo->bindColumn(2,$name);
$stpdo->bindColumn(3,$surname);
$stpdo->execute();
while($row = $stpdo->fetch(PDO::FETCH_BOUND))
echo $id.' '.$name.' '.$surname.'<br />'; // stampo i nomi
$mypdo->commit();

In pratica specifico prima come devono chiamarsi i dati letti da una query e di che tipo devono essere.
a variabile $id non l’avevo mai creata, nonostante ciò non ho avuto nessun notice o warning perche’ questa viene popolata e inizializzata ( se inesistente ) automaticamente all’ interno della chiamata a bindColumn.
Poi la variabile viene automaticamente riassegnata ad ogni ciclo del while ,
permettendoci di evitare i soliti $row[N] per il fetch_row o $row['key'] per il fetch_assoc.

bindColumn

$mypdo->beginTransaction();
// preparo la query
$stpdo = $mypdo->prepare("SELECT * FROM first_table ");
$stpdo->bindColumn(1,$id, PDO::PARAM_INT);
$stpdo->bindColumn(2,$name, PDO::PARAM_STR);
$stpdo->bindColumn(3,$surname, PDO::PARAM_STR);
$stpdo->execute();
while($row = $stpdo->fetch(PDO::FETCH_BOUND))
echo $id.' '.$name.' '.$surname.'<br />'; // stampo i nomi
$mypdo->commit();


i parametri non modificano il risultato, ma “forse” ottimizzano le query

così abbiamo visto anche come funizona PDO::FETCH_BOUND

E se volessi usare Postgres invece di Mysql?
Semplice creo il DB pgsql come quello mysql e basta che cambi queste rige con i diversi parametri di connessione:

$string_dsn = 'pgsql:host=localhost;dbname=pdo'; // pgsql
$string_username = 'user';
$string_password = 'password';


ed il gioco è fatto, bello no?!

Lo studio l’ho fatto partendo da questi link:

http://it2.php.net/pdo
Pillola PDO

Gabba Gabba Hey
Bonzo

Ecco il talk che ho apprezzato di più:
Nel canale Enterprise si è assistito a un piccolo confronto tra tre CMS tra i più diffusi.

• Joomla
• Drupal
• eZpublish

Avendoli utilizzati tutti e tre, ho apprezzato e seguito con interesse il confronto e la mia piccola conclusione è che Drupal è il miglior compromesso tra potenza e semplicità (ovviamente grazie a views e cck), eZpublish è potentissimo ma adatto a grosse realtà (con le sue 102 tabelle e tutto il resto è forse troppo esoso di risorse per un semplice blog), mentre Joomla rimane un po’ staccato avendo una flessibilità minore rispetto agli altri due, nonostante ciò è quello con un community maggiore, quindi è sempre da tenere d’occhio.

Oltre a questo ho fatto in tempo a sentire il talk di Daniele Teti sui Design patterns e quello di Simone Carletti sullo zend framework ed i web services. Quest’ultimo è stato ricco di esempi e molto interessante, non a caso ho scaricato lo Zend il giorno dopo e penso che, almeno come libreria comicerò ad usarlo. Uno dei suoi vantaggi è proprio il fatto di poter essere usato a pezzi, non costringendo il programmatore a sapere tutto sul framework.

Dal Blog di Fullo un po’ di Link su foto, video e altro dell’evento.
Fullo Blog

Ci si vede nel 2009

Gabba Gabba Hey
Bonzo

Devo creare il meccanismo la creazione, modifica e eliminzaione dei post.

Aggiungere i Post
/app/controllers/posts_controller.php

< ?php
class PostsController extends AppController
{
var $name = 'Posts';
function index()
{
$this->set('posts', $this->Post->findAll());
}
function view($id = null)
{
$this->Post->id = $id;
$this->set('post', $this->Post->read());
}
function add()
{
if (!empty($this->data))
{
if ($this->Post->save($this->data))
{
$this->flash('Your post has been saved.','/posts');
}
}
}
}
?>


Il controller guarda che i dati inviati via POST non siano vuoti, se non lo sono utilizza il metodo per salvare i dati. Con il metodo flash è possibile visualizzare un messaggio che dice se i dati sono stati salvati.

Creo la vista add
/app/views/posts/add.thtml

< <h1>Add Post</h1>
<form method="post" action="url('/posts/add')?>">
<p>
Title:
< ?php echo $html->input('Post/title', array('size' => '40'))?>
< ?php echo $html->tagErrorMsg('Post/title', 'Title is required.') ?>
</p>
<p>
Body:
< ?php echo $html->textarea('Post/body', array('rows'=>'10')) ?>
< ?php echo $html->tagErrorMsg('Post/body', 'Body is required.') ?>
</p>
<p>
< ?php echo $html->submit('Save') ?>
</p>
</form>


ecco come si visualizza la pagina:
http://localhost/cake/posts/add

Modifico il modello Post
/app/models/post.php
aggiungo la validazione dei dati.


< ?php
class Post extends AppModel
{
var $name = 'Post';
var $validate = array(
'title' => VALID_NOT_EMPTY,
'body' => VALID_NOT_EMPTY
);
}
?>

L’array $validate dice a Cake come validare i dati quando è chiamato il metodo save(). I valori per queste chiave si possono vedere in /cake/libs/validators.php.


/**
* Not empty.
*/
define('VALID_NOT_EMPTY', '/.+/');
/**
* Numbers [0-9] only.
*/
define('VALID_NUMBER', '/^[-+]?\\b[0-9]*\\.?[0-9]+\\b$/');
/**
* A valid email address.
*/
define('VALID_EMAIL', '/\\A(?:^([a-z0-9][a-z0-9_\\-\\.\\+]*)@([a-z0-9][a-z0-9\\.\\-]{0,63}\\.(com|org|net|biz|info|name|net|pro|aero|coop|museum|[a-z]{2,4}))$)\\z/i');
/**
* A valid year (1000-2999).
*/
define('VALID_YEAR', '/^[12][0-9]{3}$/');


Ecco cosa succede se si prova ad inserire un post senza il titolo:

Cancellare i post, azione delete
/app/controllers/posts_controller.php


< ?php
class PostsController extends AppController
{
var $name = 'Posts';
function index()
{
$this->set('posts', $this->Post->findAll());
}
function view($id = null)
{
$this->Post->id = $id;
$this->set('post', $this->Post->read());
}
function add()
{
if (!empty($this->data))
{
if ($this->Post->save($this->data))
{
$this->flash('Your post has been saved.','/posts');
}
}
}
function delete($id)
{
$this->Post->del($id);
$this->flash('The post with id: '.$id.' has been deleted.', '/posts');
}
}
?>


Aggiungo il link delete nella vista index
/app/views/posts/index.thtml


< ?php
echo $html->link(
'Delete',
"/posts/delete/{$post['Post']['id']}",
null,
'Are you sure?'
)
?>


se clicco mi si apre un alert javascript che mi chiede se sono sicuro.
Se disabilito javascript nel browser il post viene cancellato senza richiesta di conferma.

Modificare i post, azione edit
/app/controllers/posts_controller.php


function edit($id = null)
{
if (empty($this->data))
{
$this->Post->id = $id;
$this->data = $this->Post->read();
}
else
{
if ($this->Post->save($this->data['Post']))
{
$this->flash('Your post has been updated.','/posts');
}
}
}


Creo la vista edit
/app/views/posts/edit.thtml


<h1>Edit Post</h1>
<form method="post" action="< ?php echo $html->url('/posts/edit')?>">
< ?php echo $html->hidden('Post/id'); ?>
<p>
Title:
< ?php echo $html->input('Post/title', array('size' => '40'))?>
< ?php echo $html->tagErrorMsg('Post/title', 'Title is required.') ?>
</p>
<p>
Body:
< ?php echo $html->textarea('Post/body', array('rows'=>'10')) ?>
< ?php echo $html->tagErrorMsg('Post/body', 'Body is required.') ?>
</p>
<p>
< ?php echo $html->submit('Save') ?>
</p>
</form>


aggiungo il link edit nella vista index
/app/views/posts/index.thtml


< ?php echo $html->link('Edit', '/posts/edit/'.$post['Post']['id']);?>


Modifica pagina di home
/app/config/routes.php

Nel file routes.php ci sono le configurazioni per i controller e le relative viste che si devono aprire per i vari indirizzi.

Modifico commentando

//$Route->connect('/', array('controller' => 'pages', 'action' => 'display', 'home'));

e settando:

/**
* Collegamento alla pagina index
*
*/
$Route->connect ('/', array('controller'=>'posts', 'action'=>'index'));

Così andando a http://localhost/cake mi apre direttamente la vista index del controller posts.

Ecco fatto, ora il sistema di gestione dei Post è finito, il prossimo obbiettivo è implementare un sistema di gestione degli utenti che possono inviare i post.

Gabba Gabba Hey
Bonzo

Creazione database

Per prima cosa
Ecco alcuni accorgimenti sulle regole che devono seguire le tabelle (naming convention):

• I nomi devono essere in plurale inglese (posts ad esempio), in modo che i modelli corrispondenti abbiano nomi in singolare;
• tutte le tabelle devono avere una chiave primaria chiamata id;
• le chiavi esterne utilizzate per costruire le relazioni tra le tabelle devono essere nomiate utilizzando il singolare della tabella a cui fanno riferimento seguito da _id (post_id per esempio);
• è possibile includere i campi created e modified che verranno automaticamente aggiornati da CakePHP quando si opererà sui record.

Cake contiente una classe inflections che si occupa di ottenere i plurali dei vari nomi.

Creo il database blog_cake.

Creo la tabella posts.

/* First, create our posts table: */
CREATE TABLE posts (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
title VARCHAR(50),
body TEXT,
created DATETIME DEFAULT NULL,
modified DATETIME DEFAULT NULL
);


/* Then insert some posts for testing: */
INSERT INTO posts (title,body,created)
VALUES ('il titolo', 'Questo è il contenuto di un post.', NOW());
INSERT INTO posts (title,body,created)
VALUES ('secondo titolo', 'Altro contenuto di un post.', NOW());
INSERT INTO posts (title,body,created)
VALUES ('Divetimento', 'Divertiamoci.', NOW());


Imposto i dati di connessione al database nel file /app/config/database.php

var $default = array('driver' => 'mysql',
'connect' => 'mysql_pconnect',
'host' => 'localhost',
'login' => '',
'password' => ' ',
'database' => 'blog_cakel' );

Cake contiene una Classe AppModel da cui si parte per ottenere i nuovi modelli, estendendo tale classe di partenza.

Creo il modello Post:

/app/models/post.php


< ?php
class Post extends AppModel
{
var $name = 'Post';
}
?>


Creo il controller Post
Dato che abbiamo deciso di seguire le convenzioni sui nomi sarà possibile accedere ai modelli implementati direttamente attraverso $this->NOME_MODELLO.
/app/controllers/posts_controller.php

< ?php
class PostsController extends AppController
{
var $name = 'Posts';
}
?>


Ci aggiungo l’azione index


< ?php
class PostsController extends AppController
{
var $name = 'Posts';
function index()
{
$this->set('posts', $this->Post->findAll());
}
}
?>

Il metodo index registra un array con tutti i post inseriti utilizzando il metodo set, che rende disponibile questo array alla vista.

Creo la vista index

/app/views/posts/index.thtml


<h1>Blog</h1>
< ?php foreach ($posts as $post): ?>
<dl>
<dt>
<h3>< ?php echo $html->link($post['Post']['title'], "/posts/view/".$post['Post']['id']); ?></h3>
< ?php
echo $post['Post']['id'];
echo '<br/>';
echo $post['Post']['created'];
echo '<br/&gt';
echo '<br/>';
?>
</dt>
<dd>
< ?php
echo $post['Post']['body'];
?>
</dd>
</dl>
< ?php endforeach; ?>


Vado con il browser all’indirizzo:
http://localhost/cake/posts/
ed ecco il risultato:

Ora aggiungo l’azione view al controller, per gestire la visualizzazione di un singolo post.


< ?php
class PostsController extends AppController
{
var $name = 'Posts';
function index()
{
$this->set('posts', $this->Post->findAll());
}
function view($id = null)
{
$this->Post->id = $id;
$this->set('post', $this->Post->read());
}
}
?>


Creo la vista view
/app/views/posts/view.thtml


<h2>< ?php echo $post['Post']['title']?></h2>
<p><small>Created: < ?php echo $post['Post']['created']?></small></p>
<p>< ?php echo $post['Post']['body']?></p>


Ora se clicco sul titolo del primo post, mi sposto all’indirizzo:
http://localhost/cake/posts/view/1

e vedo la vista view di questo post.

Così ho completato tutte le pagine per visualizzare il blog, la prossima volta passo alle pagine per inserimento, modifica e cancellazione dei post.

Gabba Gabba Hey
Bonzo

Ho quindi pensato di provare a creare il mio primo plugin per wordpress integrando questo componente.

Qui intanto gli esempi di come funziona Shadowbox:

Demos

Images

Single Image (Flickr)
Image Gallery

image
image

Large Image

You may have to shrink your browser window to view the effect here. See the handleLgImages option for more information.

Clipped (no resizing)	Resized	Draggable

Thumb Gallery

Unlike the previous image gallery, this one is triggered by thumbnail links. It also uses a skip counter and is continuous.

Flash

Single SWF
SWF Gallery
Flash Video

Movies

Single Movie (mov)
Single Movie (mpeg-4, controller disabled)
Single Movie (avi, autoplay disabled)

Single Movie (wmv)
Apple.com Trailer
YouTube
Google Video
Movie Gallery
MOV

WMV
FLV
External Website
This page
Mixed Content Gallery
swf

movie
iframe

Il Plugin è molto semplice, basta caricare la cartella che si ottiene scompattando l’archivio compresso nelal cartella /wp-content/plugins, andare nella parte di amministrazione e attivare il plugin.

Per utilizzarlo basta aggiungere rel=”shadowbox” ai link che volete aprire in questo modo.

ecco un po’ di esempi presi dal sito di shadowbox

<a href="myimage.jpg">My Image</a>

<a href="myimage.jpg" rel="shadowbox">My Image</a>

<a href="myimage.jpg" rel="shadowbox" title="My Image">My Image</a>

<a href="mymovie.swf" rel="shadowbox;height=140;width=120">My Movie</a>

<a href="myimage.jpg" rel="shadowbox;options={overlayOpacity: 0.5, resize: false}">My Image</a>

<a href="beach.jpg" rel="shadowbox[Vacation]">The Beach</a>
<a href="pier.jpg" rel="shadowbox[Vacation]">The Pier</a>

<a rel="shadowbox[Mixed];options={counterType:'skip',continuous:true}" href="vanquish.jpg">jpg</a>
<a rel="shadowbox[Mixed];width=520;height=390" href="caveman.swf">swf</a>
<a rel="shadowbox[Mixed];width=292;height=218" href="kayak.mp4">movie</a>
<a rel="shadowbox[Mixed]" href="index.html">iframe</a>

Per ora il plugin funziona con mootools, ma è facilmente adattabile ad altre librerie javascript, visto che shqdowbox include i vari adapter per queste librerie.

• Yahoo! User Interface Library (yahoo, dom, event, anim)
• Ext (standalone, ext-core.js)
• Prototype + Scriptaculous
• jQuery
• MooTools (requires Fx.Styles and its dependancies)
• Dojo Toolkit (thanks Peter Higgins)

Scarica il plugin versione 0.1
Ovviamente spero che se ci sono reeori qualcuno me lo segnali.

Gabba Gabba Hey
Bonzo