Klasa generująca formularz - dobre praktyki Opcje

[Turson]

Hej,
mam małą zagwozdkę logiczną w tworzeniu klasy generującej formularz. Teoretycznie takową klasę napisałem, ale mam kilka wątpliwości.
Od razu dodam, że aplikacja oparta jest o MVC.
Skrócony kod klasy:

[PHP] pobierz, plaintext 
<?php
class MyForm {
 
    protected $_action;
    protected $_method = 'GET';
    protected $_html;
 
    public function setAction($value) {
        $this->_action = $value;
    }
 
    public function setMethod($value) {
        $this->_method = $value;
    }
 
    public function startForm(array $options = array()) {
        $optionsHtml = '';
        if (count($options)) {
            foreach ($options as $key => $value) {
                $optionsHtml .= ' ' . $key . '="' . $value . '"';
            }
        }
        $this->_html = '<form action="' . $this->_action . '" method="' . $this->_method . '"' . $optionsHtml . '>';
    }
 
    public function endForm() {
        $this->_html .= '</form>';
    }
 
    public function createElement($type, $name, $label = null, $value = null, array $values = array(), array $options = array()) {
       // wygenerowanie kodu HTML input/textarea/select itd.
        $this->_html .= $html;
    }
 
    public function render() {
        return $this->_html;
    }
 
}
[PHP] pobierz, plaintext 

Formularz generuję w widoku, np.

[PHP] pobierz, plaintext 
<?php
$form = new MyForm();
$form->setMethod('POST');
$form->startForm();
$form->createElement('text', 'login', 'Nickname');
$form->createElement('password', 'password', 'Password');
$form->createElement('submit', 'submit', null, 'Register new account');
$form->endForm();
echo $form->render();
?>
Jakiś dalszy tekst
[PHP] pobierz, plaintext 

Tutaj mam taką rozkminę, czy formularz lepiej generować w widoku jak powyżej, czy w osobnej klasie, np. application/forms/RegisterForm.php
Pierwsze rozwiązanie widziałem w Yii, a drugie w Zendzie.

A teraz sprawa najważniejsza. Posiadam osobną klasę walidującą pola formularza wg. zasad ustalonych w modelu. Tego nie będę pokazywał, bo nie ma związku. Chcę mieć dostęp do informacji o wszystkich walidujących polach w klasie walidacyjnej.
Kontroler:
Jeżeli naciśnięto przycisk, zbieram dane z formularza, pobieram reguły walidacji i przekazuję to do klasy walidującej np. $this->validate($data, $rules)
$data zawiera tablicę $_POST. W klasie walidacyjnej następuje sprawdzenie poprawności przesłanych danych wg. $rules. W tejże klasie muszę mieć dostęp do tego jaki dane pola ma $label - i to jest cały problem. Nie mam za bardzo pomysłu jak się do tego dostać. Podejrzewam, że w klasie MyForm i metodzie createElement() muszę zapisywać dane każdego tworzonego pola i zapisywać np. w statycznej własności klasy $formData. To nie jest problem. Tylko odwołanie się do np. MyForm::$formData z klasy walidacyjnej przecież nie pobierze tych danych, bo już ich tam nie "będzie".
A po co mi wiedzieć jaki label ma dane pole? Ano po to, że jak nie przejdzie walidacji to do tablicy KlasaWalidacyjna->errors mogę dodać $label.' can not be empty'

Ten post edytował Turson 24.08.2014, 11:23:12

[Pyton_000]

Wypluwasz errory w tablicy z kluczami z name pola i w widoku robisz coś na zasadzie

[PHP] pobierz, plaintext 
if($errors->has('email') {
echo $errors->get('email)->first();
}
[PHP] pobierz, plaintext 

IHMO startForm powinno zbierać wszystkie opcje włącznie z method i action, skoro już robisz przypisanie po tablicy.
Do tego robisz małe sprawdzanie: jeżeli brak to nic nie ustawiasz w action, a method domyślnie POST

[Turson]

Z walidacją i wyświetleniem komunikatów nie mam problemu, tylko klasa walidacyjna otrzymuje tablicę $_POST nazwa_pola=>wartość, a potrzebuję dodatkowo na podstawie nazwa_pola pobrać jego label.
Czyli np. w MyFrom->createElement()

[PHP] pobierz, plaintext 
$labels[$name] = $label;
[PHP] pobierz, plaintext 

gdzieś to przechować, żebym mógł z poziomu klasy walidacyjnej się do tego odwołać <- i to nie wiem jak.

[Pyton_000]

A na co Ci to? Do reguł validujących dodajesz sobie tekst w przypadku błędu i po problemie.

[Turson]

To jest jakieś rozwiązanie, ale chciałbym, żeby w aplikacji były defaultowe komunikaty, a jak się doda w regułach customowy komunikat to wtedy on się wyświetli.

[Pyton_000]

No to dodajesz sobie w klasie Validującej odwołanie do jakiejś tablicy z tekstami (klucz nazwa pola) i sprawdzasz czy jest customowy tekst w rules a jak nie to z tłumaczeń.

[Turson]

Tablicę rules mam zbudowaną w sposób:

[PHP] pobierz, plaintext 
$rules = array(
    'register' => array(
        'NAME POLA' => array(
            'required' => true
        ),
        'NAME POLA' => array(
            'min_length' => 3
        ),
    )
);
[PHP] pobierz, plaintext 

czyli namespace formularza (tak sobie wszystko definiuję takim słowem kluczem, ale mniejsza o to) -> name pola -> reguły
Tutaj nie mam żadnego problemu jak już wspomniałem. Chcę gdzieś zapisać do każdego nowego elementu tablicę $tablica[name_pola]=>[label_pola]
I nie wiem gdzie to zapisać, żeby potem z klasy walidacyjnej odwołać się do tablicy, jeżeli mam regułę z name_pola w paremetrze, to odwołam się do $tablica[name_pola] i mam jego label. Chodzi tylko i wyłącznie o to.

[Pyton_000]

No to jedno rozwiązanie z ... :

- Robisz sobie Interface Input
- Implementujsz każdy z inputów nadając im atrybuty publiczne

Klasa Form tworzy nowe obiekty typu Input i wrzuca do jakiejś kolekcji.

W klasie validującej robisz coś na zasadzie:

$label = Form::get('email')->label;
lub coś w ten deseń.

Ten post edytował Pyton_000 25.08.2014, 08:43:31

[Turson]

Dobrze rozumiem?

[PHP] pobierz, plaintext 
<?php
class Form{
 
    protected static $_data = array();
 
    function createElement($label,$name, $value = null){
        // something
        $data = new stdClass();
        $data->label = $label;
        $data->value = $value;
        self::_putData($name,$data);
    }
 
    protected static function _putData($name, $data){
        self::$_data[$name] = $data;
    }
 
    public static function get($name){
        $data = self::$_data;
        return isset($data[$name]) ? $data[$name] : false;
    }
 
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
$form = new Form();
$form->createElement('Nickname', 'login');
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
class Validate{
 
    function doSth(){
        $input = Form::get('login');
        var_dump($input);
    }
 
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
$validate = new Validate();
$validate->doSth();
[PHP] pobierz, plaintext 

[Pyton_000]

Cos w ten deseń Tylko zamiast false zwracaj albo null albo array() jeżeli oczekujesz tablicy.

[Turson]

Już próbowałem już takiego rozwiązania i jak z klasy Validation odwoływałem się do Form::get(), to zwracało mi zawsze pustą tablicę. Dlaczego?
Wydaje mi się, że przy odwołaniu statycznym tablica $data klasy Form się czyściła. Ba, kombinowałem z Singletonem, bo myślałem że to kwestia instancji.

Ten post edytował Turson 25.08.2014, 09:14:49

[Pyton_000]

Czysta bo to kolejny request a więc dane nie są znane.
Przy odbieraniu danych z $_POST wrzuć to w Form, wygeneruj formularz na nowo ale wstawiając value dla inputów i zadziała.

Chociaż i tak uważam że to już kombinowania. Najprościej jak mówiłem, olej label i podziałaj z tekstami validacji

[Turson]

Pisanie własnego komunikatu o błędzie dla każdej reguły jest jak dla mnie średnim pomysłem, dlatego wolałbym sobie ułatwić życie i wprowadzić automatyczne teksty, jeżeli nie podano własnego. Jak będę miał czas to wrócę do tego kodu i napiszę w tym temacie, gdyby jeszcze coś było

[memory]

Może coś w ten deseń

[PHP] pobierz, plaintext 
 $rules = array(
        'name' => array( 'required' => true,'min' =>3),
        'link' => 'active_url',
    );
 
//Tworzysz sobie np  tablice domyślnych nazw:
 
  $validation = 
array("required" => "The {label} must be required.",
    "active_url" => "The {label} is not a valid URL.",);
 
W klasie walidującej
 
//tablica validation 
protected $validation = array();
protected $messages = array();
 
function validate($attribute,$rule){
 
//sprawdzanie czy poprawnie itd ($attribute = name, $rule = 'required ')
$this->addError($attribute, $rule);
 
}
 
function addError($attribute, $rule)
$this->message[$attribute] = $this->getMessage($attribute, $rule,$this->validation);
}
 
function getMessage($attribute, $rule, $source){
 
if (isset($source[$rule])) return $source[$rule];
 
}
[PHP] pobierz, plaintext 

Ten post edytował memory 25.08.2014, 11:21:46

[Turson]

@memory, ale co z "{label}" ? Nie stosujesz tutaj żadnej podmiany {label}=>$label

[RiE]

Może zamiast metody z 6 argumentami lepiej będzie przekazać do niej 1 argument w postaci tablicy w której będą się znajdowały wszystkie niezbędne informacje. Bo co w przypadku jeśli chce dodać klasę albo ID do pola tekstowego? Który parametr za to odpowiada? Ostatni? A jak będę chciał dodać klasę do label to też ostatni?

[PHP] pobierz, plaintext 
    public function createElement($type, $name, $label = null, $value = null, array $values = array(), array $options = array()) {
       // wygenerowanie kodu HTML input/textarea/select itd.
        $this->_html .= $html;
    }
[PHP] pobierz, plaintext 

Lepszym wyjściem moim zdaniem byłoby:

[PHP] pobierz, plaintext 
    protected $inputs = array();
 
    public function createElement($input) 
    {
         $this->inputs[$input['input']['name']] = $input;
    }
 
    public function getElement($name)
    {
         return $this->inputs[$name];
    }
 
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
$form = new MyForm();
$form->createElement(array(
    'input' => array(
         'name' => 'pole_1',
         'type' => 'text'
         'options' => array(
              'value' => 'Domyślna wartość',
              ...
         ),
         'attributes' => array(
              'id' => 'pole_1'
              'class' => 'form-input',
              'placeholder' => 'Tekst...',
              ...
          )
     ),
    'label' => array(),
    //'errors' => array()
));
[PHP] pobierz, plaintext 

Następnie przekazujesz ten formularz do widoku i w widoku Dekorator odpowiada za poprawne wyświetlenie.

[PHP] pobierz, plaintext 
<div class="my-form">
    <?php echo $this->renderLabel($form->getElement('pole_1)); ?>
    <?php echo $this->renderInput($form->getElement('pole_1)); ?>
    <?php echo $this->renderErrors($form->getElement('pole_1)); ?>
</div>
[PHP] pobierz, plaintext 

W renderLabel() dajesz input i tworzysz label na podstawie klucza label. W renderInput() tworzysz input na podstawie klucza input. A podczas walidacji dodajesz klucz error i jeżeli nie jest pusty to wyświetlasz błedy pod polem w którym się pojawiły.

W $rules przydałoby się jeszcze przekazać informację z jakiego validatora chcesz skorzystać bo może się zdarzyć tak że dwa validatory będą miały dwa takie same klucze np. min_length albo pattern w którym będzie wyrażenie Regexp i co wtedy? Skąd wiadomo z jakiego validatora skorzystać?

[memory]

[PHP] pobierz, plaintext 
miało być {attribute}; :).
 
function addError($attribute, $rule){
$message = $this->getMessage($attribute, $rule,$this->validation);
$message = str_replace('{attribute}', $this->getAttribute($attribute), $message);
$this->message[$attribute] = $message;
}
 
function getAttribute($attribute){
 
// tutaj porownujesz z danymi z Post czy atrybut posiada label 
 
}
 
 
[PHP] pobierz, plaintext 

[kayman]

imo klasa generująca formularz to w ogóle zła praktyka, od tego są widoki w Twigu, Smarty etc. ale ..... oto mój burdelik

[PHP] pobierz, plaintext 
 
// formularz kontaktowy
 
if ($error = Main::getSessionValue('error')) {
            Main::unsetSessionValue('error');
}
 
$form = new Form();
$form->addFile(array('type' => 'text', 'name' => 'name', 'value' => $error['name'], 'id' => 'name', 'description' => 'Imię i nazwisko lub nazwa firmy:', 'validation' => 'vname'));
$form->addFile(array('type' => 'text', 'name' => 'mail', 'value' => $error['mail'], 'id' => 'mail', 'description' => 'Adres email:', 'validation' => 'vmail'));
$form->addFile(array('type' => 'textarea', 'name' => 'message', 'value' => $error['message'], 'id' => 'message', 'description' => 'Treść wiadomości:', 'validation' => 'vmesage'));
$form->addFile(array('type' => 'text', 'name' => 'captcha', 'id' => 'captcha', 'description' => $captcha->getCaptcha(), 'validation' => 'vcaptcha'));
$form->addFile(array('type' => 'button', 'class' => 'art-button', 'value' => 'Wyślij'));
$form->addFile(array('type' => 'hidden', 'name' => 'action', 'value' => 'email'));
$this->content = $form->getForm();
 
[PHP] pobierz, plaintext 

jak widać dobra praktyka to raczej unikać takich leniwców

Ten post edytował kayman 25.08.2014, 15:34:51

[Pyton_000]

A wystarczyłoby

[PHP] pobierz, plaintext 
new InputText('name', val|null, array('params'=>'sss'));
[PHP] pobierz, plaintext 

[Turson]

Co myślicie o rozwiązaniu: w $form->createElement() w argumencie przekazuję tablicę $rules = array('required' => true), w klasie Form następuje zapisanie w sesji reguł walidujących przy konkretnych polach. Z sesji odczytam, sprawdzę i czyszczę sesję.
Zapiszę w sesji: reguły walidujące i dane pola (label, name, value itd)

Ten post edytował Turson 8.09.2014, 14:25:43

[aniolekx]

moim zdaniem możesz sobie tworzyć formularze dynamicznie w widoku, ale jeżeli chcesz do nich bindować dane to już nie tedy droga.

[Turson]

To jakie rozwiązanie, żeby budować formularz obiektem mniej więcej jak podałem, a dodatkowo po wysłaniu formularza mieć dostęp m.in. do labela podając np. jego 'name' ?