mcustomfield.class

Ir para a documentação deste ficheiro.

<?php
 
class MCustomField
{
    const FORMAT_TEXT = 'text';
    const FORMAT_LONG_TEXT = 'longText';
    const FORMAT_INTEGER = 'integer';
    const FORMAT_DECIMAL = 'decimal';
    const FORMAT_LIST = 'list';
    const FORMAT_LISTSQL = 'listsql';
    const FORMAT_MTAG = 'mtagselectionsql';
    const FORMAT_MULTI_LIST = 'multList';
    const FORMAT_MULTI_LISTSQL = 'multListsql';
    const FORMAT_DATE = 'date';
    const FORMAT_BOOLEAN = 'boolean';
    const FORMAT_HIDDEN = 'oculto';
    const FORMAT_SESCOLHA = 'sescolha';
    const FORMAT_INTERVAL = 'interval';
    const FORMAT_SESCOLHA_LIST = 'sescolhaList';
    const FORMAT_SESCOLHA_LISTSQL = 'sescolhaListsql';
    const FORMAT_JAVASCRIPT = 'javascript';
    const FORMAT_FILE = 'file';
    const FORMAT_EDITOR = 'editor';
 
    public $id;
 
    public $identifier;
 
    public $name;
    
    public $label;
 
    public $fieldFormat;
 
    public $possibleValues;
 
    public $regexp;
 
    public $minLength;
 
    public $maxLength;
 
    public $required;
 
    public $position;
 
    public $defaultValue;
 
    public $editable;
 
    public $visible;
 
    public $suffix;
    
    public $possibleParameters;
 
    public $paramNotFound;
    
    public $filtroFormularioBusca;
 
    public $visivel;
 
    public $objetoreferencia;
 
    public $largura;
 
    public $altura;
 
    public $hint;
 
    public $jshint;
 
    public function __construct($data=NULL)
    {
        if ( $data )
        {
            $this->setData($data);
        }
    }
 
    private static function getBusiness()
    {
        $MIOLO = MIOLO::getInstance();
        return new MBusiness('admin');
    }
 
    public function getInputId()
    {
        return self::generateInputId($this->identifier, $this->id, $this->suffix);
    }
 
    public static function generateInputId($identifier, $id, $suffix='')
    {
        return str_replace(" ", "_", "{$identifier}_$id$suffix");
    }
 
    public function setData($data)
    {
        $this->id = $data->id;
        $this->identifier = $data->identifier;
        $this->name = $data->name;
        $this->fieldFormat = SAGU::NVL($data->fieldFormat, $data->fieldformat);
        $this->possibleValues = SAGU::NVL($data->possibleValues, $data->possiblevalues);
        $this->regexp = $data->regexp;
        $this->minLength = SAGU::NVL($data->minLength, $data->minlength);
        $this->maxLength = SAGU::NVL($data->maxLength, $data->maxlength);
        $this->required = $data->required;
        $this->position = $data->position;
        $this->defaultValue = SAGU::NVL($data->defaultValue, $data->defaultvalue);
        $this->editable = $data->editable;
        $this->visible = $data->visible;
        $this->filtroFormularioBusca = $data->filtroFormularioBusca;
        $this->visivel = $data->visivel;
        $this->objetoreferencia = $data->objetoreferencia;
        $this->largura = $data->largura;
        $this->altura = $data->altura;
        $this->label = $data->label;
        $this->possibleParameters = $data->possibleparameters;
        $this->hint = $data->hint;
        $this->jshint = $data->jshint;
    }
 
    public function insert()
    {
        $this->id = $this->getBusiness()->_db->getNewId('miolo_custom_field_id_seq', 'miolo_sequence');
 
        $sql = new MSQL(
            'id, identifier, name, field_format, possible_values, regexp, min_length, max_length, required, position, default_value, editable, visible, filtroFormularioBusca, visivel, hint, jshint',
            'miolo_custom_field'
        );
 
        $args = array(
            $this->id,
            $this->identifier,
            $this->name,
            $this->fieldFormat,
            $this->possibleValues,
            $this->regexp,
            $this->minLength,
            $this->maxLength,
            $this->required,
            $this->position,
            $this->defaultValue,
            $this->editable,
            $this->visible,
            $this->filtroFormularioBusca,
            $this->visivel,
            $this->hint,
            $this->jshint
        );
 
        return self::getBusiness()->execute($sql->insert($args));
    }
 
    public function update()
    {
        $sql = new MSQL(
            'identifier, name, field_format, possible_values, regexp, min_length, max_length, required, position, default_value, editable, visible, filtroFormularioBusca, visivel, hint, jshint',
            'miolo_custom_field',
            'id = ?'
        );
 
        $args = array(
            $this->identifier,
            $this->name,
            $this->fieldFormat,
            $this->possibleValues,
            $this->regexp,
            $this->minLength,
            $this->maxLength,
            $this->required,
            $this->position,
            $this->defaultValue,
            $this->editable,
            $this->visible,
            $this->filtroFormularioBusca,
            $this->visivel,
            $this->hint,
            $this->jshint,
            $this->id,
        );
 
        return self::getBusiness()->execute($sql->update($args));
    }
 
    public function delete()
    {
        if ( !isset($this->id) )
        {
            return false;
        }
 
        $sql = new MSQL('', 'miolo_custom_field', 'id = ?');
        return self::getBusiness()->execute($sql->delete($this->id));
    }
 
    public function populate()
    {
        $sql = new MSQL(
            'identifier, name, label, field_format, possible_values, regexp, min_length, max_length, required, position, default_value, editable, visible, possible_parameters, filtroFormularioBusca, visivel, objetoreferencia, largura, altura, hint, jshint',
            'miolo_custom_field',
            'id = ?'
        );
 
        $query = self::getBusiness()->query($sql, $this->id);
 
        list(
            $this->identifier,
            $this->name,
            $this->label,
            $this->fieldFormat,
            $this->possibleValues,
            $this->regexp,
            $this->minLength,
            $this->maxLength,
            $this->required,
            $this->position,
            $this->defaultValue,
            $this->editable,
            $this->visible,
            $this->possibleParameters,
            $this->filtroFormularioBusca,
            $this->visivel,
            $this->objetoreferencia,
            $this->largura,
            $this->altura,
            $this->hint,
            $this->jshint
        ) = $query->result[0];
    }
 
    public function isRequired()
    {
        return $this->required == 't';
    }
 
    public function isEditable()
    {
        return $this->editable == 't';
    }
 
    public function isVisible()
    {
        return $this->visivel == 't';
    }
 
    public static function listByIdentifier($identifier, $actionURL = NULL, $step = null)
    {
        $sql = new MSQL(
            'id, identifier, name, label, field_format, possible_values, regexp, min_length, max_length, required, position, default_value, editable, visible, possible_parameters, filtroFormularioBusca, visivel, objetoreferencia, largura, altura, hint, jshint',
            'miolo_custom_field',
            '',
            'position, name'
        );
 
        $sql->addEqualCondition('identifier', $identifier);
 
        if ( $step )
        {
            $sql->addEqualCondition('passo', $step);
        }
 
        if( strlen($actionURL) > 0 )
        {
            $sql->addEqualCondition('actionURL', $actionURL);
        }
        else
        {
            $sql->setWhereAnd('actionURL IS NULL');
        }
 
        $query = self::getBusiness()->query($sql);
 
        $list = array();
 
        if ( $query->result )
        {
            foreach ( $query->result as $row )
            {
                $cf = new self();
 
                list(
                    $cf->id,
                    $cf->identifier,
                    $cf->name,
                    $cf->label,
                    $cf->fieldFormat,
                    $cf->possibleValues,
                    $cf->regexp,
                    $cf->minLength,
                    $cf->maxLength,
                    $cf->required,
                    $cf->position,
                    $cf->defaultValue,
                    $cf->editable,
                    $cf->visible,
                    $cf->possibleParameters,
                    $cf->filtroFormularioBusca,
                    $cf->visivel,
                    $cf->objetoreferencia,
                    $cf->largura,
                    $cf->altura,
                    $cf->hint,
                    $cf->jshint
                ) = $row;
 
                $list[] = $cf;
            }
        }
 
        return $list;
    }
 
    public static function listForGrid($identifier='')
    {
        $MIOLO = MIOLO::getInstance();
 
        $where = $identifier ? 'identifier = ?' : '';
 
        $sql = new MSQL(
            'id,
             identifier,
             name,
             field_format,
             possible_values,
             required,
             filtroFormularioBusca ',
            'miolo_custom_field',
            $where,
            'identifier, position, name'
        );
 
        $query = self::getBusiness()->query($sql, $identifier);
 
        return $query->result;
    }
 
    public static function listFormatFields()
    {
        return array(
            self::FORMAT_TEXT => _M('Text'),
            self::FORMAT_LONG_TEXT => _M('Long text'),
            self::FORMAT_INTEGER => _M('Integer'),
            self::FORMAT_DECIMAL => _M('Decimal'),
            self::FORMAT_LIST => _M('List'),
            self::FORMAT_LISTSQL => _M('Lista (SQL)'),
            self::FORMAT_MTAG => _M('MTagSelection (SQL)'),
            self::FORMAT_MULTI_LIST => _M('Multi-seleção'),
            self::FORMAT_MULTI_LISTSQL => _M('Multi-seleção (SQL)'),
            self::FORMAT_DATE => _M('Date'),
            self::FORMAT_BOOLEAN => _M('Boolean'),
            self::FORMAT_SESCOLHA => _M('SEscolha'),
            self::FORMAT_SESCOLHA_LIST => _M('SEscolha (Lista)'),
            self::FORMAT_SESCOLHA_LISTSQL => _M('SEscolha (Sql)'),
            self::FORMAT_JAVASCRIPT => _M('JavaScript'),
            self::FORMAT_FILE => _M('Arquivo'),
            self::FORMAT_EDITOR => _M('Editor'),
        );
    }
 
    public function __get($attr)
    {
        if ( $attr == 'sId' ) return $this->id;
        if ( $attr == 'sName' ) return $this->name;
        if ( $attr == 'sVisible' ) return $this->visible;
    }
    
    public function hasSQLParameters()
    {
        return substr_count($this->possibleValues, '?') > 0;
    }
    
    public function parsePossibleParameters()
    {
        return (array) explode(',', $this->possibleParameters);
    }
    
    public function getParameterArgs()
    {
        $MIOLO = MIOLO::getInstance();
        $args = array();
 
        foreach ( $this->parsePossibleParameters() as $parameter )
        {
            // Tenta buscar valor do REQUEST
            $requestValue = MIOLO::_REQUEST($parameter);
 
            // Se nao encontrar valor, busca do $_REQUEST ignorando maiusculas/minusculas
            if ( strlen($requestValue) == 0 )
            {
                $data = array_change_key_case($_REQUEST, CASE_LOWER);
 
                $requestValue = $data[strtolower($parameter)];
            }
            
            // Se nao encontrar valor, tenta buscar de dados de passo a passo
            if ( strlen($requestValue) == 0 )
            {
                $isFromSAGU = $MIOLO->getConf('temp.is.from.sagu');
                
                if ( $isFromSAGU )
                {
                    $data = (array) sstepbystepform::getAllStepDataStatic();
                    $data = array_change_key_case($data, CASE_LOWER);
                    
                    $requestValue = $data[strtolower($parameter)];
                }
            }
            
            if ( strlen($requestValue) == 0 && strlen($this->paramNotFound) == 0 )
            {
                $this->paramNotFound = $parameter;
            }
 
            $args[] = $requestValue;
        }
        
        return $args;
    }
    
    public function replaceSQLParameters($sql)
    {
        if ( $this->hasSQLParameters() )
        {
            $MIOLO = MIOLO::getInstance();
            $isFromSAGU = $MIOLO->getConf('temp.is.from.sagu');
            
            if ( $isFromSAGU )
            {
                $args = $this->getParameterArgs();
                
                // executa o comando de substituicao dos coringas
                $sql = SAGU::prepare($sql, $args, false);
            }
        }
        
        return $sql;
    }
    
    public function getListSQL()
    {
        $MIOLO = MIOLO::getInstance();
        $list = array();
        
        if ( strlen($this->possibleValues) > 0 && (( $this->fieldFormat == MCustomField::FORMAT_LISTSQL ) || ( $this->fieldFormat == MCustomField::FORMAT_MULTI_LISTSQL) || ($this->fieldFormat == MCustomField::FORMAT_SESCOLHA_LISTSQL) || $this->fieldFormat == MCustomField::FORMAT_MTAG))
        {
            $db = $MIOLO->GetDatabase('admin');
            $query = $db->Query($this->replaceSQLParameters($this->possibleValues));
 
            foreach ( (array) $query as $row )
            {
                $list[ $row[0] ] = $row[1];
            }
        }
        
        return $list;
    }
    
    public function getFieldHint()
    {
        if ( $this->hasSQLParameters() && strlen($this->paramNotFound) > 0 )
        {
            return _M("Não foi encontrado valor para o parâmetro '@1' configurado.", null, $this->paramNotFound);
        }
    }
    
    public function getListValues()
    {
        $possibleValues = explode("\n", trim($this->possibleValues));
        $list = array();
 
        foreach ( $possibleValues as $val )
        {
            $value = trim($val);
            $list[$value] = $value;
        }
        
        return $list;
    }
 
    public static function getCustomFieldById($id)
    {
        $name = SDatabase::queryAssociative(SDatabase::prepareSQL("
             SELECT id,
                    identifier,
                    name,
                    label,
                    field_format as fieldFormat,
                    possible_values as possibleValues,
                    possible_parameters as possibleParameters,
                    regexp,
                    min_length as minLength,
                    max_length as maxLength,
                    required,
                    position,
                    default_value as defaultValue,
                    editable,
                    visible,
                    filtroFormularioBusca,
                    visivel,
                    objetoreferencia,
                    largura,
                    altura,
                    hint,
                    jshint
               FROM miolo_custom_field
              WHERE id = ?", array($id)))[0];
 
        return new MCustomField((object) $name);
    }
}
?>