inputcontrols.class

Ir para a documentação deste ficheiro.

<?php
 
class MTextField extends MFormControl
{
    public $size; // =0 => hidden
    public $type; //text, multiline, password, file
    public $validator;
    public $rows;
    public $cols;
 
    public function __construct( $name='',$value='',$label='', $size=10, $hint='', $validator=NULL, $isReadOnly=false, $type='text' )
    {
        parent::__construct( $name, $value, $label, '', $hint );
 
        $this->setReadOnly( $isReadOnly );
        $this->size     = $size;
        $this->type     = ( ($size > 0) ) ? $type : 'hidden';
        $this->setValidator( $validator );
        $this->rows     = 1;
        $this->cols     = $this->size;
        $this->formMode = MControl::FORM_MODE_SHOW_SIDE;
        $this->formName = $this->page->getName();
    
    }
 
    function setClass($cssClass, $add = true)
    {
        parent::setClass($cssClass, $add);
        $this->cssClass .= " form-control";
    }
 
    public function getValidator()
    {
        if($this->validator && $this->validator->name)
        {
            return $this->validator;
        }
        if ( method_exists($this->form, 'getFieldValidator') )
        {
            return $this->validator = $this->form->getFieldValidator($this->name);
        }
    }
 
 
    public function setValidator( $value )
    {
        $this->validator = is_string($value) ? new MaskValidator( $name, $label, $value ) : $value;
    }
 
    public function generateInner()
    {
        if ( ( $this->label ) && ( $this->type == 'hidden' ) )
        {
            $span = new Span( $this->name, $this->value, MControl::CLASS_CAPTION ) ;
            $html = $this->painter->span( $span );
        }
 
        if ( $this->autoPostBack )
        {
            $this->AddAttribute( 'onblur', "showLoading();" .
                "$('#m-loading-message-bg, #m-loading-message').unbind('click');" .
                "$('#m-loading-message-bg, #m-loading-message').prop('onclick', null);stopShowLoading();" .
                "return _doPostBack('{$this->event}','');".
                "document.{$this->page->name}.submit();"
            );
        }
 
        if ( $this->getClass() == '' )
        {
            $this->setClass( 'm-text-field form-control' );
        }
 
        if ( $this->readonly )
        {
            $this->SetClass('m-readonly');
            $this->AddAttribute('readonly');
        }
 
        $mask = $this->getValidator()->mask ?? null;
        if ( $mask )
        {
            $this->addAttribute('onkeypress', 'return MIOLO_Validate_Mask('.$this->getValidator()->name.', event)');
            $this->addAttribute('onkeyup', 'MIOLO_Apply_Mask('.$this->getValidator()->name.', event)');
        }
 
        if ( ( $this->type=='text' )     ||
             ( $this->type=='password' ) ||
             ( $this->type=='file' )     ||
             ( $this->type=='number' )
            )
        {
            $size = '';
 
            if ( $this->type=='text' && $this->size )
            {
                $size = $this->size;
            }
 
            $text = $this->getRender('inputtext');
            $this->inner = $this->generateLabel() . $text;
        }
        else if ( ($this->type=='multiline') )
        {
            $text = $this->getRender('inputtextarea');
            $this->inner = $this->generateLabel() . $text;
        }
    }
}
 
 
class MPasswordField extends MTextField
{
    public function __construct( $name='', $value='', $label='', $size=20, $hint='', $validator=null )
    {
        parent::__construct( $name, $value, $label, $size, $hint, $validator );
 
        $this->type = 'password';
    }
}
 
 
class MHiddenField extends MTextField
{
    public function generate()
    {
        return $this->getRender('inputhidden');
    }
}
 
 
class MMultiLineField extends MTextField
{
    public function __construct( $name='', $value='', $label='', $size=20, $rows=1, $cols=20, $hint='', $validator=null )
    {
        parent::__construct( $name, $value, $label, $size, $hint, $validator );
 
        $this->type = 'multiline';
        $this->rows = $rows;
        $this->cols = $cols;
        $this->setClass('m-multiline-field form-control');
    }
}
 
 
class MFileField extends MTextField
{
    const EXT_ZIP = 'zip';
    const EXT_TAR_GZ = 'tar.gz';
    const EXT_GZ = 'gz';
    const EXT_TXT = 'txt';
    const EXT_CSV = 'csv';
    const EXT_PFX = 'pfx';
    const EXT_CER = 'cer';
    
    private $allowedExtensions = array();
    
    public $geraOnChange = true;
    
    public function __construct( $name='', $value='', $label='', $size=40, $hint='', $showMaxUpload = true )
    {
        parent::__construct( $name, $value, $label, $size, $hint );
 
        // Caso esteja num passo a passo já pode ter sido adicionado um arquivo
        $hint .= '';
        if ( strlen(MIOLO::_REQUEST('randomid')) > 0 )
        {
            $files = $this->manager->GetSession()->getValue('uploadedFiles_' . MIOLO::_REQUEST('randomid'));
 
            foreach ( $files as $uploadedFiles )
            {
                list ($userFile, $fieldFileId, $fileName) = explode('|_|', $uploadedFiles['name']);
                
                if ( $this->manager->GetLogin()->id == $userFile &&
                     $fieldFileId == $name )
                {
                    // Mostra no hint que o arquivo foi adicionado
                    $hint .= "Arquivo adicionado: <strong>{$fileName}</strong>.";
                }
            }
        }
        $this->hint = $hint;
        if ( $showMaxUpload )
            $this->hint .= 'Máx: '.$this->obterTamanhoMaximoUpload().'MB';
        $this->type = 'file';
    }
 
    public function copyFile( $path )
    {
        if( $f=$_FILES[$this->name]['tmp_name'])
        {
            copy( $f, $path );
            return true;
        }
        else
        {
            return false;
        }
    }
 
    public function getFileName( )
    {
        return $_FILES[$this->name]['name'];
    }
 
    public function getFileType( )
    {
        return $_FILES[$this->name]['type'];
    }
 
    public function getAllowedExtensions()
    {
        return $this->allowedExtensions;
    }
 
    public function setAllowedExtensions($allowedExtensions = array())
    {
        foreach ( $allowedExtensions as $ext )
        {
            $this->addAllowedExtension($ext);
        }
    }
 
    public function addAllowedExtension($extension)
    {
        $this->allowedExtensions[] = '.' . $extension;
    }
    
    public function generateInner()
    {
        if ( $this->geraOnChange )
        {
            $this->addAttribute('onchange', $this->obtemOnChange());
        }
        
        return parent::generateInner();
    }
    
    public function obterTamanhoMaximoUpload()
    {
        $maxFileSize = substr(ini_get('upload_max_filesize'), 0, -1);
        $maxPostSize = substr(ini_get('post_max_size'), 0, -1);
 
        if ($maxFileSize > $maxPostSize)
        {
            return $maxPostSize;
        }
        return $maxFileSize;
    }
    
    public function obtemOnChange()
    {
        //validator config php upload_max_filesize
        $maxFileSize = $this->obterTamanhoMaximoUpload();
        
        if ( substr(ini_get('upload_max_filesize'), -1) == 'K' || substr(ini_get('upload_max_filesize'), -1) == 'k')
        {
            $maxFileSizeBytes = $maxFileSize * 1024;
        
            $jsCode = " 
            var fileValida = document.getElementById('{$this->name}');
            if(fileValida.files && fileValida.files.length == 1)
            {           
                if ( fileValida.files[0].size > $maxFileSizeBytes) 
                {
                    alert('O Tamanho do arquivo não pode ser mais de ' + ($maxFileSizeBytes/1024) + 'KB');
                    fileValida.value = ''; //Limpa o conteudo selecionado
                }
            }
            ";
        }
        else if ( substr(ini_get('upload_max_filesize'), -1) == 'G' || substr(ini_get('upload_max_filesize'), -1) == 'g')
        {
            $maxFileSizeBytes = $maxFileSize * 2111832064;
        
            $jsCode = " 
            var fileValida = document.getElementById('{$this->name}');
            if(fileValida.files && fileValida.files.length == 1)
            {           
                if ( fileValida.files[0].size > $maxFileSizeBytes) 
                {
                    alert('O Tamanho do arquivo não pode ser mais de ' + ($maxFileSizeBytes/2111832064) + 'GB');
                    fileValida.value = ''; //Limpa o conteudo selecionado
                }
            }
            ";
        }
        else
        {
            $maxFileSizeBytes = $maxFileSize * 1048576;
        
            $jsCode = " 
            var fileValida = document.getElementById('{$this->name}');
            if(fileValida.files && fileValida.files.length == 1)
            {           
                if ( fileValida.files[0].size > $maxFileSizeBytes) 
                {
                    alert('O Tamanho do arquivo não pode ser mais de ' + ($maxFileSizeBytes/1024/1024) + 'MB');
                    fileValida.value = ''; //Limpa o conteudo selecionado
                }
            }
            ";
        }
 
         // Add JS extension validator
        $alExt = $this->getAllowedExtensions();
        if ( count($alExt) > 0 )
        {
            $sql = new MSQL();
            $showNumbers = implode(', ', $alExt);
            
            $jsCode .= "
                    var validou = false;
                    var fileElement = document.getElementById('{$this->name}');";
            
            foreach ( $alExt as $ext )
            {
                $jsCode .= "
                    if ( fileElement.value.indexOf('{$ext}') != -1 )
                    {
                        validou = true;
                    }";
            }
            
            $jsCode .= "
                if ( !validou )
                {
                    alert('As extensões permitidas são: {$showNumbers}');
                    fileElement.value = '';
                }";            
        }
        
        return $jsCode;
    }
    
    public static function uploadFiles($path = null)
    {
        $MIOLO = MIOLO::getInstance();
        $idUser = $MIOLO->GetLogin()->id;
        
        // Caminho padrão
        if ( is_null($path) )
        {
            $path = '/tmp/uploadedFilesSolisGe';
        }
        
        // Se o caminho não existir, cria
        if ( !is_dir($path) ) 
        {
            mkdir($path, 0777, true);
        }
        
        $uploadedFiles = array();
        
        // Já pode ter sido adicionado um arquivo
        if ( strlen(MIOLO::_REQUEST('randomid')) > 0 )
        {
            $files = $MIOLO->GetSession()->getValue('uploadedFiles_' . MIOLO::_REQUEST('randomid'));
 
            foreach ( $files as $jaEstaoBaixadas )
            {
                list ($userFile, $fieldFileId, $fileName) = explode('|_|', $jaEstaoBaixadas['name']);
                
                if ( $MIOLO->GetLogin()->id == $userFile )
                {
                    $uploadedFiles[$fieldFileId] = $jaEstaoBaixadas;
                }
            }
        }
        
        // Para todos as arquivos no $_FILES
        foreach ( $_FILES as $keyFileInfo => $fileInfo )
        {
            // Concatena o nome do campo com o id do usuário e o nome do arquivo e sua extensão
            $fileName = $idUser . '|_|' . $keyFileInfo . '|_|' . $fileInfo['name'];
 
            // Deleta o arquivo no destino, por via das dúvidas
            unlink("$path/{$fileName}");
            
            // Copia o arquivo da pasta temporária do $_FILES para a pasta especificada
            if ( copy($fileInfo['tmp_name'], "$path/{$fileName}") )
            {
                unlink($fileInfo['tmp_name']);
                $uploadedFiles[$keyFileInfo] = array(
                    'name' => $fileName,
                    'path' => "$path/$fileName"
                );
            }
        }
        
        return $uploadedFiles;
    }
}
 
 
class MCalendarField extends MTextField
{
    public function __construct( $name='', $value='', $label='', $size=20, $hint='', $type='calendar-win2k-1' )
    {
        // este campo vai usar o calendário javascript 
        parent::__construct( $name, $value, $label, $size, $hint);
 
        self::loadDeps($type);
 
        $this->setValidator( new DATEDMYValidator( $name, $label ) );
 
        $this->setClass('m-text-field m-calendar-field form-control');
    }
 
    public static function loadDeps($type='calendar-win2k-1')
    {
        $MIOLO = MIOLO::getInstance();
        $MIOLO->page->addScript('m_validate.js');
        $MIOLO->page->addScript('datepicker/calendar.js');
        $MIOLO->page->addScript('datepicker/lang/calendar-pt-br.js');
        $MIOLO->page->addScript('datepicker/calendar-setup.js');
 
        $styleURL = $MIOLO->getAbsoluteURL('scripts/datepicker/css/' . $type . '.css');
        $MIOLO->page->addStyleURL($styleURL);
    }
 
    public function generateInner()
    {
        parent::generateInner();
 
        if ( ! $this->readonly )
        {
            $location = $this->manager->getUI()->getImage('', 'cal.gif' );
            $imgName  = 'btn'.$this->name;
 
            $image = new MImage( $imgName, _M('Click to open the calendar'), $location );
 
            $js = "Calendar.setup({inputField:\"{$this->name}\", ifFormat:\"%d/%m/%Y\", button:\"$imgName\"});";
 
            if ( $this->page->request('cpaint_function') != "" )
            {
                $this->page->addAJAXJScode($js);
            }
            else
            {
                $this->page->onload($js);
            }
 
            $image->generateInner();
            $divInput = new MDiv('input_' . $this->name, $this->inner, 'm-input-calendar');
            $divImg = new MDiv('img_' . $this->name, $image->getInner(), 'm-img-calendar');
            $hContainer = new MHContainer('hct_' . $this->name, array($divInput, $divImg));
            $this->inner = $hContainer->generate();
        }
    }
    
    public function setFieldForm(MForm $form)
    {
        // Adiciona validador de calendario automaticamente
        $exists = false;
        
        foreach ( $form->getFieldValidators($this->name) as $validator )
        {
            if ( $validator instanceof MDateDMYValidator )
            {
                $exists = true;
            }
        }
        
        if ( !$exists )
        {
            $this->setValidator(null);
            $form->AddValidator( new MDATEDMYValidator($this->name, $this->label, $this->getRequiredType()) );
        }
        
        parent::setFieldForm($form);
    }
}
 
 
class MCurrencyField extends MTextField
{
    private $ISOCode = 'REAL';
 
    public function __construct( $name='', $value='', $label='', $size=10, $hint='' )
    {
        // este campo vai usar validacao/formatacao javascript 
        parent::__construct( $name, $value, $label, $size, $hint );
 
        $page = $this->page;
 
        $page->addScript( 'm_utils.js' );
        $page->addScript( 'm_currency.js' );
    }
 
 
    public function getValue()
    {
        // internal ($this->value): float - 12345.67
        // external (return): formated string - R$ 12.345,67
        $format = new MCurrencyFormatter();
 
        $value = $format->formatWithSymbol( $this->value, $this->ISOCode );
 
        return $value;
    }
 
 
    public function setValue( $value )
    {
        // internal ($this->value): float - 12345.67
        // external ($value): formated string - 12.345,67
        $format = new MCurrencyFormatter();
 
        $value = $format->toDecimal($value, $this->ISOCode);
        $this->value = (float)$value;
    }
 
 
    public function generateInner()
    {
        $this->addAttribute( 'onBlur', "MIOLO_Currency(document.{$this->formName}.{$this->name})" );
 
        parent::generateInner();
    }
}
 
?>