MVC, dove verificare i dati inviati con POST

[robynosse]

Ciao a tutti,

sto studiando l'architettura MVC.

Vorrei chiedervi qual è la forma migliore di verificare dei dati ricevuti tramite POST.
Diamo per scontato che le prime verifiche, su quanto inserito, siano già state fatte lato client con Javascript.

Ammettendo di avere ad esempio un nome, cognome, telefono.

- La verifica dei dati deve essere fatta dal Controller?
- Sarebbe meglio utilizzare una classe per definire l'oggetto Utente?

Procedimento:
Ricevo i dati tramite POST.
Dal controller, nel metodo che controlla la pagina, creo l'oggetto Utente che attraverso il costruttore (dell'oggetto utente) verifica la consistenza dei dati, poi passo i suddetti dati al modello (dove utilizzerò il metodo prepare)

$stmp=$pdo->prepare('insert into utenti (nome,cognome,telefono) values (?,?,?)');

che si occuperà di scriverli sul DB?

Cosa ne pensate?
Grazie,
Roberto

[m4rko80]

Ciao, l'utilita dal mio punto di vista in un MVC è proprio aver suddiviso classi o quant'altro a seconda dell'utilizzo o tipo di dati e poter creare classi o comunque del codice riutilizzabile. Se hai una parte riguardante l'utente e login mi pare corretto avere una classe per gestire le funzioni riguardanti il login/logout e una per il controllo e/o modifica magari dei dati utente.
In questo modo la classe utente ad esempio potresti riusarla per reucuerare i dati per una pagina di profilo.

[Al_katraz984]

class userController {

  public function add() {
    $fv = new formValidator();
    $fv->validateEmpty( 'nome-del-campo', 'messaggio di errore' );
    $fv->validateRange( 'nome-del-campo', 'messaggio di errore' );

    $fv->validateEmpty( 'name', 'Il campo [name] è obbligatorio' );

    if ( $fv->hasError() ) {
      //mostro i messaggi di errore
      } else {
      // faccio lavorare il controller
    }
  }
}

class formValidator {

  private $message;

  public function __construct() {
    $this->message = new ArrayObject();
  }

  public function validateEmpty( $field, $message ) {
    if ( empty( $_POST[$field] ) ) {
      $this->message->append( $message );
    }
  }

  public function hasMessage() {
    if ( $this->message->count() > 0 ) {
      return TRUE;
    }
    return FALSE;
  }

  public function getMessage() {
    return $this.>message;
  }
} 

io faccio così

[robynosse]

Ciao,


grazie della risposta!


Il mio dubbio più che altro è da dove gestire il controllo dei dati, che secondo me avrebbe logica farlo dal Controller, corregimi se sbaglio per favore, faccio un esempio:


L'utente mi invia un form tramite POST alla pagina inserisci.php.
"inserisci" è anche un metodo del controller, viene chiamato da questo metodo automaticamente:

    public function distribuitore(){
        $metodo=$this->indirizzo->getPagina();//restituisce il nome della pagina
        if(method_exists($this,$metodo )){
            $this->$metodo();// chiama il metodo che gestisce la pagina
        }else{$this->homePage();}
    }

viene quindi chiamato il metodo inserisci(), che si trova sempre all'interno del controller.
Il metodo inserisci crea un nuovo oggetto Modello e, attualamente, tramite:
$documento->setDocumento($_POST);
passo i dati al modello che si occuperà della scrittura nel DB.

    private function inserisci{
        $documento= new Modello();
        	//*******************************************
       	 $documento->setDocumento($_POST);
	//*******************************************
        $pagina=file_get_contents("vista/scrivi_documento.php");
        $this->scriviFile();
        $this->renderPagina($pagina, "Scrivi documento");
    }
    }

La mia domanda è la seguente:
La logica che verifica ad esempio che i dati contenuti nell'array $_POST siano offettivamente un 'nome' , un 'cognome' ed un indirizzo 'email' (sempre per esempio), dovrei farlo prima di inviare i dati al Modello?
...verificando i dati con delle espressioni regolari?


Io pensavo, prima di passare i dati al Modello, di creare e istanziare la classe Utente all'interno della quale ci sarebbe un metodo che restituisce i dati controllati.
Il nuovo codice sarebbe:

 private function inserisci{
       	$documento= new Modello();
	$utente=new Utente($_POST);
	$datiDaPassareAlModello=$utente->getUtente();//restituirebbe un array.
	$documento->setDocumento($datiDaPassareAlModello);
	...
}

oppure la verifica dei dati dovrebbe essere delegata interemente al Modello?


Spero di essere stato chiaro.


Grazie in anticipo,
Roberto

[robynosse]

io faccio così

Ho visto la tua risposta dopo, perfetto, come pensavo, le verifiche le deve fare il controller!

Grazie!

[Al_katraz984]

stai attento che associare i dati POST con il modello non va bene.. il modello rappresenta la struttura della tabella mentre nei dati POST potresti avere altri valori che non centrano niente con la tabella.

[robynosse]

stai attento che associare i dati POST con il modello non va bene.. il modello rappresenta la struttura della tabella mentre nei dati POST potresti avere altri valori che non centrano niente con la tabella.

Ciao,
ti chiedo gentilmente di analizzare le 3 parti di codice che ho scritto sotto e darmi un parere per favore, quando avrai 5/10 minuti di tempo.
Pensavo, tramite un metodo all'interno del controller, di inviare i dati controllati al modello, in questo caso andrebbe bene, vero?

//citroviamo dentro al controller
private function inserisci(){
         $documento= new Modello();
         $datiInviareModello=$this->controllaDati($_POST);
         $documento->setDocumento($datiInviareModello);
    }

---------------------------------------------------------------------------------------
ALTRA SOLUZIONE
Oppure, sarebbe corretto concettualmente, secondo te, creare una classe, ad esempio Utente, creare il metodo costruttore della classe Utente che controlla i dati $_POST e passare questo oggetto al modello?

//ci troviamo all'interno del controller
private function inserisci(){
         $documento= new Modello();
         $utente=new Utente($_POST);
         $documento->setDocumento($utente);
    }

Il modello avrà il seguente metodo

//ci troviamo all'interno del modello
public function setDocumento(Utente $utente){
         //tramite i metodi get della classe Utente recupero i dati da scrivere nel DB
    }

Sarebbe corretto in questo modo?


Ti ringrazio per la pazienza e dell'attenzione ! ;-)


Grazie!


Roberto

[Al_katraz984]

Le due soluzioni sono entrambe valide, dipende da come vuoi affrontare il problema

Prima soluzione:
Possiamo dire che il compito del controller sarebbe quello di controllare i dati e quindi un metodo controllaDati() ci può anche stare.

Con operazioni semplici il controllo può essere veloce ma se i dati iniziano ad essere tanti e variabili le cose diventano difficili da gestire su un solo metodo

Da un punto di vista più SOLID

La seconda soluzione:

$utente=new Utente($_POST); 

è totalmente errata, ma impostandola diversamente può funzionare

$datiValidi = new ValidatoreDatiUtente($_POST); 

questa struttura ti porterebbe ad una gerarchia del tipo

abstract class Validatore
abstract class ValidatoreDati extends Validatore
class ValidatoreDatiUtente extends ValidatoreDati


Successivamente per continuare con l'esempio che hai proposto

//ci troviamo all'interno del controller
private function inserisci(){
  $documento= new Modello();
  $utente=new Utente($_POST);
  $documento->setDocumento($utente);
} 

Stai cercando di fare un inserimento nella tabella e il modello non ti serve.. il modello ti serve solamente in visualizzazione dei dati (quando fai i fetch delle righe) *vedi post successivo

un metodo generico di inserimento utente:

    public function insert() {
        // il form di inserimento dati
        $form = new view( 'user-add-form' );

        // se qualcuno ha inviato dati dal form "user-add"
        if ( isset( $_POST['user-add-form-submit'] ) ) {
            // li valido tutti
            $fv = new formValidator();
            $fv->validateEmpty( 'email', 'The field [email] is required' );
            $fv->validateEmpty( 'password', 'The field [password] is required' );

            // se ci sono errori
            if ( $fv->checkErrors() ) {
                // creo il messaggio di errore
                $message = new view( 'message', $fv->displayErrors(), array( 'class'=>'error-message' ) );
                // lo attacco al form
                $form->message = $message;
                } else {
                // se non ci sono errori
                // inserisco i dati nella tabella
                $this->mapper->insert();

                // creo il messaggio di inserimento avvenuto con successo
                $message = new view( 'message', $this->mapper->getMsg(), array( 'class'=>'service-message' ) );
                // lo attacco al form
                $form->message = $message;
            }
        }

        // aggancio il form alla vista globale
        $this->view->content = $form;
    } 

nello specifico se vogliamo utilizzare il ValidatoreDatiUtenti

// bla bla

// se qualcuno ha inviato dati dal form "user-add"
if ( isset( $_POST['user-add-form-submit'] ) ) {
    $validatore = new ValidatoreDatiUtente( $_POST );

    if ( $validatore->hasError() ) {
        // creo il messaggio di errore
        } else {
        // inserisco i dati
    }
} 

Tra le due meglio la seconda anche se più complessa della prima IMHO

[Al_katraz984]

Per quanto riguarda i modelli

public function fetch( $id ) {
    $selectQuery = "SELECT * FROM $this->table WHERE id = :id LIMIT 0,1";

    $data = $this->pdo->executeQuery( $query, array( ':id'=>$id ) )->fetch();
    if ( empty( $data ) ) {
        return NULL;
    }

    // qui uso il modello
    return new modelloUtente( $data );
} 

il modelloUtente mi garantisce di avere sempre i dati correttamente popolati in base al formato della tabella che viene interrogata. In più mi permette di visualizzari i dati anche in modi diversi dal normale

un modello generico di utente:

class userModel extends entity {

    protected $fields = array( 
        'id',
        'name',
        'email',
        'password',
        'datetime',
        'active',
        'valid',
        'groupid',
        'groupname',
        'picture'
    );

    public function getItDatetime() {
        $date = new DateTime( $this->values->offsetGet( 'datetime' ) );
        return $date->format( "d-m-Y H:i:s" );
    }
} 

come puoi vedere ci sono i campi della tabella (per non sbagliare la selezione)

$modello = new userModel( $data );

// questo è valido
echo $modello->name;

// questo no
echo $modello->divano;

echo $modello->datetime;
// 2014-08-29 15:40:00

echo $modello->itDatetime;
// 29-08-2014 15:40:00 

ma solo in visualizzazione

[robynosse]

$form = new view( 'user-add-form' );

// se qualcuno ha inviato dati dal form "user-add"
if ( isset( $_POST['user-add-form-submit'] ) ) {
// li valido tutti
$fv = new formValidator();
$fv->validateEmpty( 'email', 'The field [email] is required' );
$fv->validateEmpty( 'password', 'The field [password] is required' );

// se ci sono errori
if ( $fv->checkErrors() ) {
// creo il messaggio di errore
$message = new view( 'message', $fv->displayErrors(), array( 'class'=>'error-message' ) );
// lo attacco al form
$form->message = $message;
} else {
// se non ci sono errori
// inserisco i dati nella tabella
$this->mapper->insert();

// creo il messaggio di inserimento avvenuto con successo
$message = new view( 'message', $this->mapper->getMsg(), array( 'class'=>'service-message' ) );
// lo attacco al form
$form->message = $message;
}
}

// aggancio il form alla vista globale
$this->view->content = $form;
}

[/php]

Non so veramente come ringraziarti ! :-)

Sarebbe sempre meglio avere una classe Modello (astratta) ed estenderla per ogni specifica tabella del DB, vero?
Sarebbe meglio anche avere una classe Controller ed estenderla per ogni specifica pagina, cosa ne pensi?

L'unica perplessità che mi rimane è: meglio utilizzare una classe per gestire la vista, vero?
Nell'esempio che sto studiando e plasmando a mio uso, la vista la organizzo in questo modo:
All'interno del controller ho un metodo:

private function  renderPagina($pagina,$titolo){
        global $base;//indirizzo base della pagina
        
        $pagina= preg_replace($this->getPatrone("head"), file_get_contents("vista/head.php"), $pagina);
        $pagina= preg_replace($this->getPatrone("titolo"), $titolo, $pagina);
        $pagina= preg_replace($this->getPatrone("menu"), file_get_contents("vista/menu.php"), $pagina);
        $pagina= preg_replace($this->getPatrone("strato_inserisci"), file_get_contents("vista/strato_inserisci.php"), $pagina);
        
        $pagina= preg_replace($this->getPatrone("STRATO_SCRIVI_DOCUMENTO"), file_get_contents("vista/strato_scrivi_documento.php"), $pagina);
        $pagina= preg_replace($this->getPatrone("MESSAGGIOINSERIMENTOFILE"), "File scritto", $pagina);
        //  #MESSAGGIOINSERIMENTOFILE#
        //#MESSAGGIOINSERIMENTORECORD#
        $pagina= preg_replace($this->getPatrone("PIEDI"), file_get_contents("vista/piedi.php"), $pagina);
        $pagina= preg_replace($this->getPatrone("BASE"), $base, $pagina);
        echo $pagina;
    }

Il metodo getPatrone($stringa) è questo:

    private function getPatrone($nome){
        $nome="/\#".strtoupper($nome)."\#/ms";
        return $nome;
    }

I file della vista sono tipo questo:
inserisci.php

<!DOCTYPE html>
<html lang="es">
  #HEAD#
  <body>
    <div class="container">
      #MENU#
      #STRATO_INSERISCI#
      #PIEDI#
    </div> 
  </body>
</html>

[]
strato_inserisci.php

<form enctype="multipart/form-data" action="#BASE#scrivi_documento" method="post" id="formInserimento">
    <input type="text" placeholder="nome" name="nome" required="">
     <input type="text" placeholder="inserisci le etichette separate da una virgola" name="etichette" required="">
<input type="text" placeholder="inserisci data" name="data">
<input type="file" placeholder="inserisci il file" name="immagine" required="">
<input type="submit" value="Registra" id="bottoneRegistra">
</form>

Il sito è piccolo, mi rendo conto che in questo modo vengono effettuate operazioni innecesarie di sostituzione.

Non riesco a figurarmi nello specifico esempio che hai fatto, come strutturare la classe view:
$message = new view( 'message', $this->mapper->getMsg(), array( 'class'=>'service-message' ) );

Grazie per la pazienza e sopportazione! ;-)

Roberto