Criar formulário de forma simples
Tudo bem pessoal,
Não sei se é só comigo, mas detesto ficar criando formulários, estilizar, validar e quando tem upload de imagens piorou. Então a um tempo criei uma classe que faz isso tudo para mim, muita gente pode pensar que estou reinventando a roda e estão certos, mas não é uma simples roda essa é de liga leve. Imaginem poder criar um formulário, validar, estilizar e por ai vai, mas tudo de forma fácil e com poucas linhas de código.
Segue o modelo de como é feita a criação de um formulário.
$form = array('nome'=>array('required'),
'email'=>array('label|E-mail', 'required|E-mail inválido','function'=>array('validar_email'=>'E-mail inválido')),
'genero'=>array('type|radio', 'value'=>array('Masculino|m', 'Feminino|f'), 'checked|m'),
'cidade'=>array('type|select', 'value'=>array('Belo Horizonte|BH', 'São Paulo|SP'), 'selected|BH', 'onchange|teste(); valida();'),
'telefone'=>array('onchange|formatar_telefone(this);', 'class|input_telefone'),
'cpf'=>array('object'=>array('Pessoa->validar'=>'Informe CPF válido', 'Number::set'),
'mensagem'=>array('type|textarea', 'cols|30', 'rows|20'),
'fotos'=>array('type|file', 'count|5', 'checked'=>array('image/jpeg', 'image/png'), 'dir|temp', 'maxsize|1024')
);Existem 2 métodos para criar o formulário.
$form->createForm(); // Cria um formulário simples
/*
Cria o formulário usando o framework Formee (http://www.formee.org/).
Obs. Acessei hoje e ele esta off (uma pena). Tem cópias na net, quem não achar me avisa que envio.
*/
$form->createFormee();
Mas se você quiser pegar apenas os 'inputs' é só usar $form->email_input;
Para pegar os valores é só chamar o nome do campo $form->email;Obs.: Não utilizem underline ("_") para criar os nomes dos campos, apenas para criar as ações. Desta forma você pode criar qualquer ação para o input.
Ex.: $form->email_value = 'teste@gmail.com';
Ex.: $form->email_id = 'email_principal';
Ex.: $form->email_class = 'css_email';Na classe existem mais informações de como usa-la, qualquer dúvida é só gritar.
<?php
/**
* @author Wesley David Santos
* @email wesleydavidsantos@gmail.com
* @date 26/02/2014
* @twitter @wesley_dav
*
* Classe responsável por gerar de forma dinâmica os Inputs do form
*
* De modo fácil e rápido pode ser criado qualquer tipo de formulário.
*
* O INPUTS podem ser informados via ARRAY ou OBJECT
* Podem informados qualquer tipo de FUNCTION ou OBJECT para validação de dados
* Cada INPUT pode receber parametros únicos, incluindo JS, CSS entre outros
*
*
*
* ## Criando um formulário via ARRAY único ##
*
* Exemplo 1:
*
* $form = array('nome'=>array('required'),
* 'email'=>array('label|Informe seu e-mail', 'required|E-mail inválido' , 'function'=>array('validar_email'=>'E-mail inválido')),
* 'genero'=>array('type|radio', 'value'=>array('Masculino|m', 'Feminino|f'), 'checked|m'),
* 'interesse'=>array('type|checkbox', 'label|Informe seus interesses', 'value'=>array('Música', 'Festa', 'Carro', 'Cerveja'), 'checked'=>array('Festa', 'Cerveja')),
* 'cidade'=>array('type|select', 'value'=>array('Belo Horizonte|BH', 'São Paulo|SP'), 'selected|BH', 'onchange|teste(); valida();'),
* 'telefone'=>array('onchange|formatar_telefone(this);', 'class|input_telefone'),
* 'cpf'=>array('object'=>array('Pessoa->validar'=>'Informe CPF válido', 'Number::set'),
* 'mensagem'=>array('type|textarea', 'cols|30', 'rows|20'),
* 'fotos'=>array('type|file', 'count|5', 'checked'=>array('image/jpeg', 'image/png'), 'dir|temp', 'maxsize|1024')
* );
*
* $formulario = new Form( $form );
* echo $formulario->createForm(); >> Saída sem formatação
* echo $formulario->createFormee(); >> Saída usanda a classe CSS Formee ([http://www.formee.org/](http://www.formee.org/))
* >> OBS <<
* - Para uma melhor formatação do FORMEE você pode informar o tamanho de cada GRID
* - O tamanho máximo de cada GRID é 12, quando você informa o tamanho do GRID no INPUT e no INPUT posterior
* você não informar o tamanho, então é calculado e usado valor restante até chegar a 12
* - Exemplo:
* $form = array('nome'=>array('grid|4'),
* 'sobrenome'=>array(),
* );
*
* * O INPUT 'nome' terá o tamanho de GRID 4 e o 'sobrenome' terá o tamanho de GRID 8
*
*
*
* ## Criando um formulário com os atributos de um objeto recebendo um ARRAY ##
*
* Exemplo 2:
*
* $form = new Form();
* $form->nome = array('required');
* $form->email = array('label|Informe seu e-mail', 'required|E-mail inválido' , 'function'=>array('validar_email'=>'E-mail inválido'));
* $form->genero = array('type|radio', 'value'=>array('Masculino|m', 'Feminino|f'), 'checked|m');
* $form->interesse = array('type|checkbox', 'label|Informe seus interesses', 'value'=>array('Música', 'Festa', 'Carro', 'Cerveja'), 'checked'=>array('Festa', 'Cerveja'), 'onchange|teste(); valida();');
* $form->cpf = array('object'=>array('Pessoa->validar'=>'Informe CPF válido', 'Number::set');
* $form->fotos = array('type|file', 'count|5', 'checked'=>array('image/jpeg', 'image/png'), 'dir|temp', 'maxsize|1024');
*
* echo $formulario->createFormee();
*
*
* ## Criando um formulário passando os parametros pelo atributo do objeto ##
*
* Exemplo 3:
*
* $form = new Form();
* $form->nome_required = '';
*
* $form->email_label = 'Informe seu e-mail';
* $form->email_required = 'E-mail inválido';
* $form->email_function = array('validar_email'=>'E-mail inválido', 'email_unique');
* $form->cpf_object = array('object'=>array('Pessoa->validar'=>'Informe CPF válido', 'Number::set');
*
*
* $form->genero_type = 'radio';
* $form->genero = array('Masculino|m', 'Feminino|f'), 'checked|m');
* $form->genero_checked = 'm';
*
* $form->fotos_type = 'file';
* $form->fotos_count = 5;
* $form->fotos_checked = array('image/jpeg', 'image/png');
* $form->fotos_dir = 'temp';
* $form->fotos_maxsize = 1024;
*
* echo $formulario->createFormee();
*
*
*
* ## Resumindo ##
* Um formulário pode ser criado de 3 formas distintas, podendo também misturar estas 3 formas.
*
*
*
* ## Ações especiais ##
*
* Existem ações especiais que podem ser adicionadas a cada INPUT
*
* >> required << O termo 'required' informa que o preenchimento do campo é obrigatório,
* o segundo argumento ('required|Preencha o campo') é a mensagem de alerta para o usuário,
* quando o segundo argumento não for informado é exibida a imagem padrão "$msg_required" com o nome do INPUT
*
* >> function << Você pode informar funcões PHP para serem executadas e validar campos INPUT quando o formulário for preenchido,
* esta ação deve retornar um valor BOOLEAN, a ação 'function' pode possuir uma mensagens de alerta em casos de erro,
* quando essas mensagens não são informadas é apresentada uma mensagem default "$msg_function" com o nome do INPUT
*
* >> object << Você pode informar Objetos que devem ser usados para validar campos INPUT quando o formulário for preenchido
* esta ação deve retornar um valor BOOLEAN, a ação 'object' pode possuir uma mensagens de alerta em casos de erro,
* quando essas mensagens não são informadas é apresentada uma mensagem default "$msg_object" com o nome do INPUT
*
* >> grid << Para usar a classe FORMEE você pode informar o tamanho de cada GRID, desta forma você consegue definir o STYLE do seu
* formulário, informando quais INPUTS ficaram alinhados na mesma linha
*
*
*
* ## Informações Úteis ##
*
* - O SUBMIT é verificado de forma automática e os valores informados pelo usuário no formulário são atualizados automaticamente
*
* - Para verificar se o formulário foi preenchido corretamente utilize o método '$form->checked()'
*
* - Para cadastrar os valores no banco de dados é só utilizar o próprio objeto gerado para criar o formulário
*
* - A qualquer momento você pode retornar o valor de cada campo INPUT.
* - Exemplo: echo $form->nome; # Retorna o valor atual do formulário, se o formulário foi enviado irá retornar o valor preenchido pelo usuário
* echo $form->nome_type; # Retorna o tipo de INPUT
* echo $form->nome_function; # Retorna as funções do INPUT
*
* - Para receber o HTML de um INPUT é só executar o nome do INPUT seguido de '_input'.
* - Exemplo echo $form->nome_input; # Retorna o HTML do INPUT. String
*
*
* ## Upload - como usar ##
*
* - Para realizar o upload dos arquivos execute o método "$formulario->uploadFiles()" ele irá retornar um Array com o nome dos arquivos.
* - Se você deseja receber os valores originais dos arquivos anexados, execute "$form->fotos_file" irá retornar um Array
* - Obs.: Não é necessário alterar o 'enctype' do form, ele é alterado automaticamente quando é verificado a existencia de um INPUT do tipo FILE
*
*
* ## Defaults ##
*
* Ao instanciar a Classe Form é gerado os valores do "form" e "button" eles podem ser alterados a qualquer momento.
* Exemplo:
* $form->form_method = 'get';
* $form->form_class = 'form_contato';
*
* $form->button_type = 'button';
* $form->button_value = 'Cadastrar';
*
* - Obs.: Não é necessário alterar o 'enctype' do form, ele é alterado automaticamente quando é verificado a existencia de um INPUT do tipo FILE
*
**/
class Form extends Submit{
public $join = '|'; # Caracter usado para unir a ação e o seu valor . Ex. array('name|wesley');
private $inputs = array(); # Armazena todos os inputs com seus respectivos valores
private $html_input = array(); # Armazena os HTML dos INPUTS criados
private $name; # Armazena o nome do INPUT que esta sendo acessado no momento
private $action; # Armazena a ação do INPUT que esta sendo acessado no momento
public $msg_required; # Mensagem padrão para campos obrigatórios
public $msg_function; # Mensagem padrão para funções que retornarem FALSE
public $msg_object; # Mensagem padrão para objetos que retornarem FALSE
private $reserved_words = array('grid', 'function', 'object'); # Informa as ações que não participam do INPUT
private $actions_required = array( 'type'=>'text', 'label'=>'%name', 'placeholder'=>'%label' ); # Informa as ações obrigatórias no input, valores com % indica que o conteúdo será de outro campo
private $error_list = array(); # Armazena a lista de erros encontrados
/**
* Inicializa os INPUTS
*/
public function __construct( $form = array() ){
# Cria o padrão do FORM
$this->form = array( 'action'.$this->join.'#', 'method'.$this->join.'post', 'error'.$this->join.'true' ); # Informa o tipo de formulário
$this->button = array( 'type'.$this->join.'submit', 'value'.$this->join.'Enviar', 'class'.$this->join.'right' ); # Apresenta o Botão do formulário
$this->msg_required = 'Campo %s obrigatório';
$this->msg_function = 'Campo %s inválido';
$this->msg_object = 'Campo %s inválido';
if( is_array( $form ) ){
foreach( $form as $key => $value ){
if( is_string( $value ) )
$this->$value = array();
else
$this->$key = $value;
}
}
}
/**
* Método que informa se o formulário foi preenchido corretamente
* @return Boolean
*/
public function checked(){
$this->createInputs(); # Verifica se o formulário já sofreu a opção de enviar # Retorna o valor atual
return ( $this->_isset() && sizeof( $this->getError() ) == 0 ) ? true : false;
}
/**
* Retorna os erros de preenchimento do formulário
* @return Array
*/
public function getError( $input = '' ){
if( empty( $input ) ){
return array_unique( $this->error_list );
}else{
if( isset( $this->inputs[$input]['erro'] ) && !empty( $this->inputs[$input]['erro'] ) )
return "<span class='error'>* ".$this->inputs[$input]['erro']."</span>";
}
}
/**
* Retorna os erros de preenchimento do formulário
* @return Array
*/
public function getErrorTxt(){
$erro = $this->getError();
if( sizeof( $erro ) > 0 ){
$erro = '* '. implode( '<br />* ', $erro );
}else{
$erro = '';
}
return $erro;
}
/**
* Método que verifica se o INPUT já existe senão ele é criado
*/
private function setInput( $name ){
# Separa o nome do input da ação
if( strpos( $name, '_' ) !== false ){
$new_name = explode( '_', $name );
$this->name = $new_name[0];
$this->action = $new_name[1];
}else{
$this->name = $name;
$this->action = '';
}
if( !isset( $this->inputs[ $this->name ] ) ) $this->inputs[ strtolower( $this->name ) ] = array();
}
/**
* Retorna os valores especificos de cada input
* @example $form->titulo; # Retorna o valor do input. String
* @example $form->titulo_type; # Retorna o tipo de arquivo. String
* @example $form->fotos_file; # Retorna os dados do upload. Array
*/
public function __get( $name ){
$action = '';
if( strpos( $name, '_' ) !== false ){
$name = explode( '_', $name );
$action = $name[1];
$name = $name[0];
}
if( !isset( $this->inputs[ $name ] ) ) return '';
if( $action == 'input' ){
$this->createInputs();
return $this->html_input[ $name ];
}
if( $action != '' ){
# Verifica se o usuário quer os dados dos arquivos de upload
if( $this->inputs[ $name ]['type'] == 'file' && $action == 'file' )
return $this->getFiles( $name );
else
return $this->inputs[ $name ][ $action ];
}
if( $this->_isset() ){
# Retorna o valor atual
$this->name_hidden_valid = $this->form_name;
$this->type_submit = $this->form_method;
return $this->get( $name );
}else{
return $this->inputs[ $name ][ 'value' ];
}
}
/**
* Gera os inputs com suas ações e respectivos valores
*/
public function __set( $name, $actions ){
$this->setInput( $name );
if( $this->action != '' ){
$this->inputs[ $this->name ][ $this->action ] = $actions;
}else{
if( is_array( $actions ) ){
foreach( $actions as $key => $act ){
if( is_array( $act ) ){
# Cria o atributo para receber o valor
$new_name = $name . '_' . $key;
if( $key == 'value' ){
$list_value = array();
foreach( $act as $sub_act ){
# Verifica se o valor foi informado, senão usa um único como Label e Valor
if( strpos( $sub_act, $this->join ) !== false ){
$sub_act = explode( $this->join, $sub_act );
$label = $sub_act[0];
$value = $sub_act[1];
}else{
$label = $value = $sub_act;
}
# Armazena os valores
$list_value[] = array( 'label'=>$label, 'value'=>$value );
}
# Seta o valor
$this->$new_name = $list_value;
}else{
# Seta o valor
$this->$new_name = $act;
}
}else{
if( strpos( $act, $this->join ) !== false ){
$act = explode( $this->join, $act );
$new_name = $name . '_' . $act[0];
$this->$new_name = $act[1];
# Verifica se o formulário possui upload, se sim muda automáticamente o tipo de formulário
if( $act[0] == 'type' && $act[1] == 'file' ) $this->form_enctype = 'multipart/form-data';
}else{
# Verifica se é um campo obrigatório, se sim informa a mensagem padrão
if( $act == 'required' ){
$new_name = $name . '_' . $act;
$this->$new_name = sprintf( $this->msg_required, ucfirst( $this->name ) );
}
}
}
}
}else{
# A ação VALUE é a única que não precisa ser informada desta forma quando o ATRIBUTO NAME for setado sem nenhum ACTION o value será usado
$new_name = $this->name . '_value';
$this->$new_name = $actions;
}
}
}
/**
* Método que recebe o array contendo as ações do INPUT e o transforma em uma String formatada
* @param $actions Array
* @param $param_value = String - Informa o valor que deve substituir algum parametro passado
* @return String
*/
private function actionToString( $actions, $param_value='' ){
$mount = array();
foreach( $actions as $key => $value ){
if( in_array( $key, $this->reserved_words ) ) continue;
# Verifica se é necessário alterar alguma parametro passado.
# Exemplo: onclick="alterar(%value)"
if( $param_value != '' && !is_array( $value ) && strpos( $value, '%value' ) !== false ){
$value = str_replace( '%value', $param_value, $value );
}
$mount[] = $key . '="' . $value . '"';
}
return implode( ' ', $mount );
}
/**
* Método que gera o HTML de cada INPUT
* @return Array
*/
private function createInputs(){
$this->validInputs();
foreach( $this->inputs as $name => $mount ){
$inputs_html = array();
# Input do tipo CHECKBOX deve ter seu nome no formato de array
if( in_array( $mount['type'], array('checkbox', 'file') ) ) $mount['name'] = $mount['name'] . '[]';
if( $name == 'form' ){
unset( $mount['error'] );
$inputs_html[] = "<form " . $this->actionToString( $mount ) . ">";
# Cria um input hidden para validar o formulário que esta sendo enviado
$name_form = $this->form_name;
$this->$name_form = array('type|hidden', 'value|validForm', 'name|'.$name_form);
$inputs_html[] = "<input " . $this->actionToString( $this->inputs[ $this->form_name ] ) . ">"; # Campo para validar o formulário enviado
$inputs_html = implode( '', $inputs_html );
}else{
switch( $mount['type'] ){
case 'radio': $value = $mount['value'];
$checked = $mount['checked'];
unset( $mount['value'], $mount['checked'] );
if( sizeof( $value ) == 0 ) exit( 'Informe os campos do radio button. <strong>'.$mount['name'].'</strong>' );
foreach( $value as $v ){
if( $v['value'] == $checked ){
$inputs_html[] = '<input ' . $this->actionToString( $mount, $v['value'] ) . ' value="'.$v['value'].'" checked />' . $v['label'];
}else{
$inputs_html[] = '<input ' . $this->actionToString( $mount, $v['value'] ) . ' value="'.$v['value'].'"/>' . $v['label'];
}
}
$inputs_html = implode( '<br />', $inputs_html );
break;
case 'checkbox': $value = $mount['value'];
$checked = isset( $mount['checked'] ) ? $mount['checked'] : array();
unset( $mount['value'], $mount['checked'], $mount['required'] );
if( sizeof( $value ) == 0 ) exit( 'Informe os campos do checkbox. <strong>'.$mount['name'].'</strong>' );
foreach( $value as $v ){
if( is_array( $checked ) && in_array( $v['value'], $checked ) ){
$inputs_html[] = '<input ' . $this->actionToString( $mount, $v['value'] ) . ' value="'.$v['value'].'" checked />' . $v['label'];
}else{
$inputs_html[] = '<input ' . $this->actionToString( $mount, $v['value'] ) . ' value="'.$v['value'].'" />' . $v['label'];
}
}
$inputs_html = implode( '', $inputs_html );
break;
case 'select': $value = $mount['value'];
$selected = $mount['selected'];
unset( $mount['value'], $mount['selected'], $mount['type'] );
$inputs_html[] = "<select " . $this->actionToString( $mount ) . ">";
foreach( $value as $v ){
if( $v['value'] == $selected ){
$inputs_html[] = '<option value="'.$v['value'].'" selected>' . $v['label'] . '</option>';
}else{
$inputs_html[] = '<option value="'.$v['value'].'">' . $v['label'] . '</option>';
}
}
$inputs_html[] = "</select>";
$inputs_html = implode( '', $inputs_html );
break;
case 'textarea': $value = $mount['value'];
unset( $mount['value'], $mount['type']);
if( !isset( $mount['cols'] ) ) $mount['cols'] = 30;
if( !isset( $mount['rows'] ) ) $mount['rows'] = 10;
$inputs_html = '<textarea ' . $this->actionToString( $mount ) . '>'.$value.'</textarea>';
break;
case 'file': $count = $mount['count'];
unset( $mount['count'] );
$count = (isset($count) && is_numeric($count)) ? $count : 1;
for( $c=0; $c < $count; $c++ ) $inputs_html[] = '<input ' . $this->actionToString( $mount ) . ' />';
break;
default: $inputs_html = '<input ' . $this->actionToString( $mount ) . ' />';
}
}
$this->html_input[ $name ] = $inputs_html;
}
return $this->html_input;
}
/**
* Método que verifica se os INPUTs foram informados corretamente
* @return Array
*/
private function validInputs(){
foreach( $this->inputs as $name => $input ){
# Obrigátorio informar o nome do INPUT
if( !isset( $input[ 'name' ] ) ){
if( $name == 'form' || $name == 'button' ){
$name_form = '';
foreach( $this->inputs as $key => $value ) $name_form .= $key;
$this->inputs[ $name ]['name'] = md5( $name_form );
}else{
$this->inputs[ $name ]['name'] = $name;
}
}
# Obrigátorio informar o nome do INPUT
if( !isset( $input[ 'name' ] ) ){
if( $name == 'form' || $name == 'button' ){
$name_form = '';
foreach( $this->inputs as $key => $value ) $name_form .= $key;
$input['name'] = md5( $name_form );
}else{
$input['name'] = $name;
}
$this->inputs[ $name ]['name'] = $input['name'];
}
# Verifica se as ações obrigatórias foram informadas
foreach( $this->actions_required as $act => $value ){
if( !isset( $input[ $act ] ) && $name != 'form' && $name != 'button' ){
# Verifica se o valor é o conteúdo de outro campo
if( strpos( $value, '%' ) !== false ){
$value = $input[ str_replace( '%', '', $value ) ];
}
if( $act == 'label' )
$this->inputs[ $name ][$act] = ucfirst( $value );
else
$this->inputs[ $name ][$act] = $value;
}
}
}
$this->submit(); # Verifica se o formulário já sofreu a opção de enviar
}
/**
* Verifica se o formulário foi enviado, se sim atualiza os valores pelos preenchidos no formulário
*/
private function submit(){
$this->name_hidden_valid = $this->form_name;
$this->type_submit = $this->form_method;
if( $this->_isset() ){
foreach( $this->inputs as $name => $inp ){
$reserved_words = array_merge( array( 'form', 'button'), $this->reserved_words );
if( in_array( $name, $reserved_words ) ) continue;
$new_value = $name;
switch( $this->inputs[ $name ][ 'type' ] ){
case 'select':
$new_value = $name.'_selected';
break;
case 'radio':
case 'checkbox': $new_value = $name.'_checked';
break;
case 'file': $name_checked = $name.'_checked';
$type_valid = array();
if( is_array( $this->$name_checked ) && sizeof( $this->$name_checked ) > 0 ) $type_valid = $this->$name_checked;
$error_file = $this->checkedFiles( $name, $type_valid, $this->inputs[$name]['maxsize'] );
if( sizeof( $error_file ) > 0 ){
foreach( $error_file as $er ){
$this->inputs[$name]['erro'] = $er;
$this->error_list[] = $er;
}
}
break;
}
# Atualiza os valores dos INPUTS
$value = $this->$name;
$this->$new_value = $value;
# Verifica se o campo é obrigatório
if( isset( $inp['required'] ) ){
if( is_array( $value ) && sizeof( $value ) == 0 ){
$this->inputs[$name]['erro'] = $inp['required'];
$this->error_list[] = $inp['required'];
}
if( $value == '' ){
$this->inputs[$name]['erro'] = $inp['required'];
$this->error_list[] = $inp['required'];
}
}
# Verifica se o campo deve passar por alguma função de validação
if( isset( $inp['function'] ) ){
foreach( $inp['function'] as $key_func => $name_func ){
# Verifica se é uma função com uma mensagem de erro pronta
if( is_string( $key_func ) ){
if( !$key_func( $value ) ){
$this->inputs[$name]['erro'] = $name_func;
$this->error_list[] = $name_func;
}
}else{
if( !$name_func( $value ) ){
$this->inputs[$name]['erro'] = sprintf( $this->msg_function, $name );
$this->error_list[] = sprintf( $this->msg_function, $name );
}
}
}
}
# Verifica se o campo deve passar por algum OBJECT
if( isset( $inp['object'] ) ){
foreach( $inp['object'] as $key_obj => $name_obj ){
# Verifica se o objeto tem uma mensagem de erro pronta
if( is_string( $key_obj ) ){
$obj = $key_obj;
$msg = $name_obj;
}else{
$obj = $name_obj;
$msg = $this->msg_object;
}
# Verifica como irá executar o Object
if( strpos( $obj, '->' ) ){
$obj = explode( '->', $obj );
$new_obj = new $obj[0]();
if( !$new_obj->$obj[1]( $value ) ){
$this->inputs[$name]['erro'] = sprintf( $msg, $name );
$this->error_list[] = sprintf( $msg, $name );
}
}else{
if( strpos( $obj, '::' ) ){
$obj = explode( '::', $obj );
if( !$obj[0]::$obj[1]( $value ) ){
$this->inputs[$name]['erro'] = sprintf( $msg, $name );
$this->error_list[] = sprintf( $msg, $name );
}
}
}
}
}
}
}
}
/**
* Gera um formulário no formato HTML utilizando a class FORMEE
* @return String
*/
public function createFormee(){
if( $this->form_class == '' )
$this->form_class = 'formee';
else
$this->form_class = $this->form_class . ' formee';
$inputs = $this->createInputs();
$grid_old = 0;
$form = $inputs[ 'form' ];
$button = $inputs['button'];
unset( $inputs[ 'form' ], $inputs['button'], $inputs['validform'] );
$inputs['button'] = $button; # Coloca o button no final do array
$input_form = array();
foreach( $inputs as $name => $inp ){
$type = $name.'_type';
if( $this->$type == 'hidden' ){
$input_form[] = implode( '', (array) $inp );
continue;
}
# Verifica se o GRID foi informado, se sim ele é usado, senão é usado um novo GRID que tem o valor gerado de acordo com o GRID anterior
if( isset( $this->inputs[ $name ]['grid'] ) && is_numeric($this->inputs[ $name ]['grid']) ){
$grid = $this->inputs[ $name ]['grid'] ;
}else{
$grid = 12 - $grid_old;
}
$grid = $grid == 0 ? 12 : $grid;
$grid_old = ($grid + $grid_old) > 12 ? $grid : ($grid + $grid_old);
$label = '';
if( $this->inputs[ $name ]['label'] != '' ){
$erro = '';
if( $this->form_error && $this->inputs[$name]['erro'] != '' ) $erro = "<span class='error'>* ".$this->inputs[$name]['erro']."</span>";
$label = "<label>" . ucfirst( $this->inputs[ $name ]['label'] ) . " %s ".$erro."</label>";
}
switch( $this->$type ){
case 'file':$type = $name.'_type';
$count = $name.'_count';
$count = $this->$count;
$grid_inteno = $count >= 4 ? 3 : ceil( 12 / $count );
$input_form[] = "<div class='grid-".$grid."-12'>" . sprintf( $label, '' ) . "</div>";
foreach( $inp as $key => $input_file ){
$input_form[] = "<div class='grid-".$grid_inteno."-12'>" . $input_file . "</div>";
}
$input_form[] = "</div>";
break;
case 'radio':
case 'checkbox':$type = $name.'_type';
$count = sizeof( $inp );
$grid_inteno = $count >= 4 ? 3 : ceil( 12 / $count );
$input_form[] = "<div class='grid-".$grid."-12'>" . sprintf( $label, '' );
foreach( $inp as $key => $input_file ){
$input_form[] = "<div class='grid-".$grid_inteno."-12'>" . $input_file . "</div>";
}
$input_form[] = "</div>";
break;
default: $input_form[] = "<div class='grid-".$grid."-12'>" . sprintf( $label, '' ) . implode( '', (array) $inp ) . "</div>";
}
}
return $form . implode( '', $input_form ) . '</form>';
}
/**
* Gera um formulário no formato HTML básico
* @return String
*/
public function createForm(){
$inputs = $this->createInputs();
$form = $inputs[ 'form' ];
$button = $inputs['button'];
unset( $inputs[ 'form' ], $inputs['button'], $inputs['validform'] );
$inputs['button'] = $button; # Coloca o button no final do array
$input_form = array();
foreach( $inputs as $name => $inp ){
$label = '';
if( $this->inputs[ $name ]['label'] != '' ) $label = "<label>" . ucfirst( $this->inputs[ $name ]['label'] ) . "</label><br />";
$input_form[] = $label . implode( '', (array)$inp ) . "<br />";
}
return $form . implode( '', $input_form ) . '</form>';
}
/**
* Método que realiza o UPLOAD de todos os arquivos anexados
* @return Array - Nome das imagens
*/
public function uploadFiles(){
# O upload só é feito se o formulário estiver preenchido corretamente
if( !$this->checked() ) return '';
$name_files = array();
foreach( $this->inputs as $name => $input ){
if( $input['type'] == 'file' ){
# É obrigatório informar o nome do diretório para upload dos arquivos
if( !isset( $input['dir'] ) || $input['dir'] == '' ) exit( 'Diretório para upload não informado. input > ' . $name );
# Se existir uma barra no final ela é retirada
$dir = rtrim( $input['dir'], '/' ) . '/';
if( !(file_exists( $dir ) && is_dir( $dir ) ) ){
mkdir($dir, 0755);
}else{
# Verifica se o diretório tem permissão de escrita
if(!is_writable($dir)) chmod($dir, 0755);
}
$name_files = $this->upload( $name, $dir );
}
}
return $name_files;
}
}/**
* Classe abstrata responsável por validar requisições do formulário
*/
abstract class Submit{
# Extensões de upload inválidas
private $uploadBadExtensions = array('file/php', 'file/php3', 'file/phtml', 'file/exe', 'file/cfm', 'file/shtml', 'file/asp', 'file/pl', 'file/cgi', 'file/sh', 'file/vbs', 'file/jsp');
# Informa o nome do Formulário que esta sendo acessado
protected $name_hidden_valid;
# Informa o tipo de submit usado $_POST ou $_GET
protected $type_submit;
/**
* Método responsável por retornar valores vindos por POST
* @var $param > Nome do POST
* @var $type > Tipo de retorno Integer, String, etc
*/
protected function get( $param ){
if( !$this->_isset() ) return '';
/* O método abaixo retira qualquer tag html*/
if( $this->type_submit == 'post' )
$value = $_POST[ $param ];
else
$value = $_GET[ $param ];
//$value = trim( $value );
//return is_array( $value ) ? $value : filter_var( $value , FILTER_SANITIZE_STRING);
if( !is_array( $value ) ){
if ( get_magic_quotes_gpc() )
$value = htmlspecialchars( stripslashes((string)$value) );
else
$value = htmlspecialchars( (string)$value );
}
return $value;
}
/**
* Verifica se algum post foi enviado
* @return BOOLEAN
*/
protected function _isset(){
if( $this->type_submit == 'post' )
return ( isset( $_POST[ $this->name_hidden_valid ] ) && sizeof( $_POST[ $this->name_hidden_valid ] ) > 0 ) ? true : false;
else
return ( isset( $_GET ) && sizeof( $_GET ) > 0 ) ? true : false;
}
/**
* Método responsável por verificar se exisite valor no POST
* @var $param > Nome do POST
* @var $type > Tipo de retorno Integer, String, etc
*/
protected function _empty( $param ){
/* Se não foi enviado nenhum post retorna 0 para ser tratado */
if( $this->isset() ) if($this->get( $param ) != "" ) return true;
return false;
}
/**
* Método especial que retorna o valor do GET em url amigável do parâmetro desejado
*/
protected function getFriendly( $varGet ){
/**
* @var $resp -> Variável de retorno
*/
$resp = '';
/**
* Força o $varGet a ser uma String
*/
$varGet = (string) $varGet;
/**
* Busca as informações da URL
*/
$url = isset($_GET["url"]) && $_GET["url"] != "" ? $_GET["url"] : '';
/**
* Adiciona uma barra invertida no final de cada URL
*/
if( substr( $url, ( strlen( $url ) - 1), 1 ) != '/' ) $url = $url . '/';
$parametros = explode("/", $url);
/**
* Verifica se algo foi encontrado
*/
if( sizeof( $parametros ) > 0 ){
foreach( $parametros as $var ){
/**
* Pecorre cada posição se a variável desejada for encontrada é retornado a posição
* corrente do array, isso pode ser feito pois quando o foreach apresenta um resultado
* a posição do array já muda para a próxima
*/
if( $var == $varGet ){
$resp = current( $parametros );
break;
}
}
}
return utf8_decode( $resp );
}
/**
* Verifica se algum file foi enviado
* @return BOOLEAN
*/
protected function issetFile(){
return ( isset( $_FILES ) && sizeof( $_FILES ) > 0 ) ? true : false;
}
/**
* Método que retorna os dados dos arquivos de upload
* @param $name - Nome do INPUT file
* @return Array
*/
protected function getFiles( $name ) {
$file_post = $_FILES["$name"];
$file_ary = array();
$file_count = count($file_post['name']);
if( $file_count > 0 ){
$file_keys = array_keys($file_post);
for ($i=0; $i<$file_count; $i++) {
foreach ($file_keys as $key) {
if( $file_post['error'][$i] == 0 ) $file_ary[$i][$key] = $file_post[$key][$i];
}
}
}
return $file_ary;
}
/**
* Método que válida os arquivos de upload
* @param $name - Nome do INPUT file
* @param $type_valid - Array com os tipos de arquivos válidos
* @param $maxsize - Verifica se o tamanho do arquivo é válido
* @return Array
*/
protected function checkedFiles( $name, $type_valid, $maxsize ){
$files = $this->getFiles( $name );
$error = array();
foreach( $files as $f ){
if( in_array( $f['type'], $this->uploadBadExtensions ) ){
$error[] = 'Formato inválido do arquivo ' . $file['name'];
}else{
if( sizeof( $type_valid ) > 0 && !in_array( $f['type'], $type_valid ) )
$error[] = 'Formato inválido arquivo ' . $f['name'];
else{
if( is_numeric( $maxsize ) && $f['size'] > $maxsize ) $error[] = 'Tamanho inválido arquivo ' . $f['name'];
}
}
}
return $error;
}
/**
* Função que realiza o Upload dos arquivos
* @param $name - Nome do INPUT file
* @param $directory - Nome do diretório onde será armazenado os arquivos
* @return Array - Nome dos arquivos
*/
protected function upload( $name, $directory ){
$files = $this->getFiles( $name );
$name_files = array();
if( sizeof( $files ) > 0 ){
foreach( $files as $f ){
$type = explode( '/', $f['type'] );
$name_files[] = $name_arq = md5( uniqid(rand(), true) ) . '.' . $type[1]; # Gera um nome de forma aleatória
/* Faz o upload da imagem para seu respectivo caminho */
move_uploaded_file( $f["tmp_name"], $directory . $name_arq );
}
}
return $name_files;
}
}Discussão (4)
Carregando comentários...