Come utilizzare la classe di convalida del modulo ExpressionEngine nel modulo per ripopolare il modulo nel modello?

Question

È possibile visualizzare errori e ripopolare i campi in un modulo codificato in un modello? Finora ho solo capito come visualizzare gli errori nella vista di un modulo, ma non in un modello.

In base alla logica di ExpressionEngine, suppongo di dover rendere in qualche modo visibili gli errori di convalida attraverso un tag nel mio modulo, o anche di generare l'intero modulo dal modulo, ma non sono sicuro di come fare al meglio avvicinarsi a questo.

Ecco quello che ho adesso.

function submit_form() 
{   
    $this->EE->load->helper('form'); 
    $this->EE->load->library('form_validation'); 

    $this->EE->form_validation->set_rules('first_name', 'First Name', 'required'); 
    $this->EE->form_validation->set_rules('last_name', 'Last Name', 'required'); 
    $this->EE->form_validation->set_rules('address', 'Address', 'required'); 
    $this->EE->form_validation->set_rules('city', 'City', 'required'); 
    $this->EE->form_validation->set_rules('province', 'Province', 'required'); 

    if ($this->EE->form_validation->run() == FALSE) 
    { 
     return $this->EE->load->view('form_errors'); 
    } 
    else 
    { 
     // success 
    } 
} 

E per i test, la vista contiene semplicemente:

echo validation_errors(); 

chiunque può aiutare?

Answer 1

Ottima domanda, e una che mi ha richiesto molto tempo per capire il modo migliore per risolvere.

Il CodeIgniter Form Validation library è ottimo, ma può essere utilizzato solo con viste e controller appropriati, quindi non funziona immediatamente quando si sviluppa un tag front-end.

Normalmente, il modo migliore di inviare un modulo di front-end è registrare un 'Azione' nel file upd.addon.php (suppongo che tu abbia fatto questo per la tua funzione submit_form()). A questo viene quindi assegnato un numero, che puoi postare con l'url /index.php?ACT=37 o qualcosa di simile. Questo è un buon sistema, perché significa che sappiamo che l'invio del modulo proviene dal nostro modulo. Tuttavia, con i moduli di input, questo è un ostacolo, perché significa che non possiamo ripopolare i campi di input. È quindi necessario configurare il modulo di input per postare nuovamente all'URL corrente e attendere fino a quando il motore del modello tenta di eseguire il rendering del tag prima di gestire l'invio del modulo.

Il modo più semplice e visivamente più brutto per raggiungere questo obiettivo è utilizzare $this->EE->output->show_user_error(FALSE, array_of_errors). Puoi effettivamente usarlo da un'azione o dal codice del modulo. Mostra la pagina di messaggio EE grigia standard che tutti abbiamo imparato a conoscere e odiare.

Con questo tipo di introduzione, probabilmente sapevi che la soluzione non sarebbe stata così semplice, giusto? Ecco uno scheletro di una funzione di tag che implementa il controllo degli errori in linea:

function my_form() 
{ 
    // load default tag variables 
    $tag_vars = array(); 
    $tag_vars[0] = array(
     'first_name' => '', 
     'error:first_name' => '', 
     'last_name' => '', 
     'error:last_name' => '' 
    ); 

    // handle a form submission 
    if ($this->EE->input->post('my_form_hidden') == '1')) 
    { 
     // load POST data into tag 
     $tag_vars[0]['first_name'] = $this->EE->input->post('first_name', TRUE); 
     $tag_vars[0]['last_name'] = $this->EE->input->post('last_name', TRUE); 

     // use CI validation library to check submission 
     $this->EE->load->helper('form'); 
     $this->EE->load->library('form_validation'); 
     $this->EE->form_validation->set_rules('first_name', 'lang:first_name', 'required'); 
     $this->EE->form_validation->set_rules('last_name', 'lang:first_name', 'required'); 

     $valid_form = $this->EE->form_validation->run(); 
     if ($valid_form) 
     { 
      // probably save something to database, then redirect 
     } 
     else 
     { 
      $form_errors = array(); 
      foreach (array('first_name', 'last_name') as $field_name) 
      { 
       $field_error = form_error($field_name); 
       if ($field_error) 
       { 
        $form_errors[] = $field_error; 
        $tag_vars[0]['error:'.$field_name] = $field_error; 
       } 
      } 

      if ($this->EE->TMPL->fetch_param('error_handling') != 'inline') 
      { 
       // show default EE error page 
       return $this->EE->output->show_user_error(FALSE, $form_errors); 
      } 
     } 
    } 

    // parse and output tagdata 
    $out = $this->EE->functions->form_declaration(array(
     'action' => $this->EE->functions->fetch_current_uri(), 
     'hidden_fields' => array('my_form_hidden'))); 
    $out .= $this->EE->TMPL->parse_variables($tagdata, $tag_vars); 
    return $out.'</form>'; 
} 

In questo modo, il progettista può specificare error_handling="inline" nel tag se vogliono errori in linea, altrimenti saranno solo reindirizzati al modulo standard error. Se lo fanno richiedere la gestione degli errori in linea, saranno semplicemente bisogno di assicurarsi che i loro ingressi simile a questa:

<input type="text" name="first_name" value="{first_name}" /> 
{error:first_name} 

Nota il campo nascosto sottoponiamo insieme al modulo, questo ci permette di essere sicuri di gestire solo la presentazione delle questo modulo e non altri moduli nella pagina, come un modulo di accesso o qualcosa del genere. Se hai più di una istanza del tuo modulo su una pagina (ad esempio all'interno di un ciclo di voci del canale o qualcosa del genere), dovrai implementare alcuni trucchi per assicurarti di gestire solo l'istanza del modulo che è stata inoltrata, ad esempio inoltrandola entry_id anche come campo nascosto.

Felice di averlo documentato, speriamo che questo sia utile anche per altri sviluppatori EE!