lepton_request.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
class LEPTON_request extends LEPTON_abstract
{
 
    public static $instance;
 
    public string $strict_looking_inside = "post";
    
    public bool $error_mode = false;
 
    public string $logFileName = "LEPTON_request.log";
 
    public string $logFilePath = "/temp/secure/";
 
    public array $errors = [];
 
    public function initialize()
    {
        // comes from parent
    }
 
    public function testPostValues(array &$aValueList ): array
    {
        $this->strict_looking_inside = "post";
        
        $aReturnList = [];
        foreach($aValueList as $term => $options)
        {
            $aReturnList[ $term ] = $this->get_request( 
                $term, 
                $options['default'], 
                $options['type'], 
                (isset($options['range']) ? $options['range'] : "" )
            );
        }
        
        return $aReturnList;
    }
        
    public function testGetValues(array &$aValueList): array
    {
        $this->strict_looking_inside = "get";
        
        $aReturnList = [];
        foreach($aValueList as $term => $options)
        {
            $aReturnList[ $term ] = $this->get_request(
                $term,
                $options['default'],
                $options['type'],
                (isset($options['range']) ? $options['range'] : "" )
            );
        }
        
        return $aReturnList;
    }
 
 
    public function get_request(string $aName="", string|int|array|float|null $aDefault=null, string $type="", string|array $range="")
    {
        
        if ($aName == "")
        {
            return NULL;
        }
 
        if (false === $this->strict_looking_inside)
        {
 
            if (strtoupper($_SERVER['REQUEST_METHOD']) == "POST")
            {
                $return_value = (true === array_key_exists ($aName , $_POST) ) ? $_POST[$aName] : $aDefault;
            } 
            else 
            {
                $return_value = (true === array_key_exists ($aName , $_GET) ) ? $_GET[$aName] : $aDefault;
            }
        } 
        else 
        {
            switch (strtolower($this->strict_looking_inside)) 
            {
                case 'post':
                    $return_value = (true === array_key_exists($aName , $_POST) ) ? $_POST[$aName] : $aDefault;
                    break;
                    
                case 'get':
                    $return_value = (true === array_key_exists($aName , $_GET) ) ? $_GET[$aName] : $aDefault;
                    break;
                    
                case 'request':
                    $return_value = (true === array_key_exists($aName , $_REQUEST) ) ? $_REQUEST[$aName] : $aDefault;
                    break;
                    
                default:
                    $return_value = NULL;
                    break;
            }
        }
        
        if ($type != "") 
        {
            $this->testType($aName, $type, gettype($return_value));
            
            switch (strtolower($type)) 
            {
                //  [1] Integers
                //  1.1
                case 'integer':
                case 'number':        
                    $return_value = intval($return_value);
                    if (!is_int($return_value)) {
                        $return_value = $aDefault;
                    } else {
                        if ( true === is_array($range) )
                        {
                            $this->check_range($type, $return_value, $aDefault, $range);
                        }
                    }
                    break;
                
                //  1.2 Only positive integers (without 0)
                case 'integer+':
                    $return_value = intval($return_value);
                    if (!is_int($return_value))
                    {
                        $return_value = $aDefault;
                    }
                    
                    if ($return_value <= 0)
                    {
                        $return_value = $aDefault;
                    }
                    
                    if (true === is_array($range) )
                    {
                        $this->check_range($type, $return_value, $aDefault, $range);
                    }
                    break;
                    
                //  1.3 Only negative integers (without 0)
                case 'integer-':
                    $return_value = intval($return_value);
                    if (!is_int($return_value))
                    {
                        $return_value = $aDefault;
                    }
                    
                    if ( $return_value >= 0)
                    {
                        $return_value = $aDefault;
                    }
                    
                    if ( true === is_array($range) )
                    {
                        $this->check_range($type, $return_value, $aDefault, $range);
                    }
                    break;
            
                /*  1.4 decimal
                 *      Keep in mind that we only replace the "," (Comma) with "." (decimal-dot)!  
                 *      to save a valid value in the database.
                 *
                 *  e.g. "Win 1.234.300 Euro" will become "1234300"
                 *       "1.300.000,34" will become "1300000.34"
                 *       "1.300.000.27" will become "1300000.27"
                 *       "-23,99" will become "-23.99"
                 */ 
                case 'float':
                case 'double':
                case 'decimal': // -12.350,78 
                    //  1.4.1 remove all NONE numbers (but keep '.', ',' and '-')                
                    $sPattern = "/[^0-9-,\.]/i";
                    $return_value = preg_replace (
                        $sPattern, 
                        "",
                        (string)$return_value
                    );
                    
                    //  1.4.2 replace existing "," with "."
                    $return_value = str_replace(",", ".", $return_value);
                    
                    //  1.4.3 force to keep at last ONE dot (.)
                    $aTemp = explode(".", $return_value);
                    
                    //  1.4.3.1 more than one dot found!
                    if(count($aTemp) > 2)
                    {
                        $sPrefix = array_pop($aTemp);
                        $return_value = implode("", $aTemp).".".$sPrefix;    
                    }
                    
                    //  1.4.4 the range
                    if ( true === is_array($range) )
                    {
                        $this->check_range($type, $return_value, $aDefault, $range);
                    }
                    break;
                
                         
                //  [2] Strings
                //  2.1
                case 'string':
                    //    keep in mind that pdo add slashes automatically    via prepare and execute
                    if (!is_string((string)$return_value))
                    {
                        $return_value = $aDefault;
                    }
                    
                    if (true === is_array($range))
                    {
                        $this->check_range($type, $return_value, $aDefault, $range);
                    }
                    break;
                
                //  2.2 string without any html tags
                case 'string_clean':      
                    if (!is_string((string)$return_value))
                    {
                        $return_value = $aDefault;
                    }
                    else
                    {
                        $return_value = htmlspecialchars(strip_tags($return_value));
                    }                
                    break;    
 
                //  2.3 string with all html-tags converted to htmlspecialchars
                case 'string_chars':
                    
                    if (!is_string((string)$return_value))
                    {
                        $return_value = $aDefault;
                    }
                    else
                    {
                        $return_value = lib_lepton::getToolInstance("htmlpurifier")->purify($return_value);
                        $return_value = htmlspecialchars($return_value);
                    }                
                    break;
                
                //  2.4 string without tags but allowed html-tags
                case 'string_allowed':
                
                    if (!is_string((string)$return_value))
                    {
                        $return_value = $aDefault;
                    }
                    else
                    {
                        $return_value = strip_tags($return_value, $range);                    
                    }                
                    break;                        
                
                
                
                //  [4] E-Mail
                case 'email':
                    if (false === LEPTON_handle::checkEmailChars($return_value))
                    {
                        $return_value = '';
                    }
                    break;
 
                //  [5] Date(-s)
                //  [5.1]
                case 'date':
                    $format = 'Y-m-d';
                    $d = DateTime::createFromFormat($format, $return_value);
                    $result = $d && $d->format($format) == $return_value;
                    if ($result === false) {
                        $return_value = $aDefault;
                    }
                    break;
                
                //  [5.2]
                case 'datetime':
                    $format = 'Y-m-d H:i:s';
                    $d = DateTime::createFromFormat($format, $return_value);
                    $result = $d && $d->format($format) == $return_value;
                    if ($result === false) {
                        $return_value = $aDefault;
                    }
                    break;
                    
                //  [5.3]
                case 'datetime_local':
                    $format = 'Y-m-dTH:i:s';
                    $d = DateTime::createFromFormat($format, $return_value);
                    $result = $d && $d->format($format) == $return_value;
                    if ($result === false) {
                        $return_value = $aDefault;
                    }
                    break;
 
                //  [5.4]
                case 'month':
                    $format = 'Y-m';
                    $d = DateTime::createFromFormat($format, $return_value);
                    $result = $d && $d->format($format) == $return_value;
                    if ($result === false) {
                        $return_value = $aDefault;
                    }
                    break;
 
                //  [5.5]
                case 'time':        // hour 00:00                       
                    $format = 'H:i';
                    $d = DateTime::createFromFormat($format, $return_value);
                    $result = $d && $d->format($format) == $return_value;
                    if ($result === false) {
                        $return_value = $aDefault;
                    }
                    break;
                    
                //  [5.6]
                case 'week':        
                    // $format = 'Y-W[0-9]{2}';
                    $result = preg_match("/^[1-9][0-9]{3}[-][W][0-9]{2}$/", $return_value);
                    if ($result != 1) {
                        $return_value = $aDefault;
                    }
                    break;                  
                    
                //  [6] Arrays
                case 'array':
                    if (!is_array($return_value))
                    {
                        $return_value = $aDefault;
                    }
                    break;
                
                //  [7] RegExp
                case 'regexp':
                    if ((true === is_array($range)) && (isset($range['pattern'])))
                    {
                        $test = preg_match($range['pattern'], $return_value);
                        if ($test !== 1)
                        {
                            $return_value = $range['default'] ?? $aDefault;
                        }
                    }
                    break;
                
                //  [8]
                default:
                    // nothing above match.
                    break;
            }
        }
        return $return_value;     
    }
 
    static public function add_slash(string &$sText="" ): void 
    {
        if (substr($sText, 0,1) != "/")
        {
            $sText = "/".$sText;
        }
        
        if (substr($sText, -1) != "/")
        {
            $sText .= "/";
        }
    }
    
    private function check_range(string $type, int|string|array|float &$value, int|string|array|float &$default, string|array|float|int &$range)
    {
 
        if ($value === NULL)
        {
            return true;
        }
 
        if (!array_key_exists('use', $range))
        {
            $range['use'] = 'default';
        }
 
        if (!array_key_exists('min', $range))
        {
            $range['min'] = 0;
        }
 
        if (!array_key_exists('max', $range))
        {
            $range['max'] = 255;
        }
 
        if (!array_key_exists('char', $range))
        {
            $range['char'] = " ";
        }
 
        switch (strtolower($type) )
        {
            case 'integer':
            case 'integer+':
            case 'integer-':
            case 'float':
                if (($value < $range['min']) || ($value > $range['max']))
                {
                    switch (strtolower($range['use']))
                    {
                        case 'default': 
                            $value = $default;
                            break;
                            
                        case 'min':
                            $value = $range['min'];
                            break;
                            
                        case 'max':
                            $value = $range['max'];
                            break;
                            
                        case 'near':
                            if ($value <= $range['min'])
                            {
                                $value = $range['min'];
                            }
 
                            if ($value >= $range['max'])
                            {
                                $value = $range['max'];
                            }
                            break;
 
                        default:
                            // nothing
                            break;
                    }
                }
                break;
 
            case 'string':
                $nc = strlen($value);
 
                if (($nc < $range['min']) || ($nc > $range['max']))
                {
 
                    switch(strtolower($range['use']))
                    {
                        case 'default':
                            $value = $default;
                            break;
 
                        case 'fill':
                            for ($i=$nc; $i<=$range['min'];$i++)
                            {
                                $value .= $range['char'];
                            }
                            break;
 
                        case 'cut':
                            $value = substr(
                                $value,
                                0,
                                ( isset($range['max'])
                                    ? intval($range['max'])
                                    : $nc 
                                )
                            );
                            break;
 
                        default:
                            // nothing - keep value as it is
                            break;
                    }
                }
                break;
 
            default:
                // nothing
                break;
        }
        return true;
    }
 
 
    static public function getRequest(string $sField = "")
    {
        $sReturnValue = filter_input(
            INPUT_GET,
            $sField,
            FILTER_VALIDATE_REGEXP,
            [ "options"     => [
                "regexp"    => "~^[a-z0-9-_]{2,}$~i",
                "default"   => NULL
            ]]
        );
 
        if (NULL !== $sReturnValue)
        {
            return $sReturnValue;
        } 
        else 
        {
             return filter_input(
                INPUT_POST,
                $sField,
                FILTER_VALIDATE_REGEXP,
                [ "options"   => [
                      "regexp"    => "~^[a-z0-9-_]{2,}$~i",
                      "default"   => NULL
                    ]
                ]
            );
        }
    }
 
    static public function getPageID()
    {
        if (defined("PAGE_ID"))
        {
            return PAGE_ID;
        }
        
        $sField="page_id" ;
         
        $sReturnValue = filter_input(
            INPUT_GET,
            $sField,
            FILTER_VALIDATE_REGEXP,
            [ "options"     => [
                    "regexp"    => "~^[1-9-]?[0-9]*$~",
                    "default"   => NULL
                ]
            ]
        );
 
        if (NULL !== $sReturnValue)
        {
            return $sReturnValue;
        } 
        else 
        {
            return filter_input(
                INPUT_POST,
                $sField,
                FILTER_VALIDATE_REGEXP,
                [ "options"     => [
                        "regexp"    => "~^[1-9-]?[0-9]*$~",
                        "default"   => NULL
                    ]
                ]
            );
        }
    }
 
    protected function testType(string $name, string $expected, string $getTypeResult): void
    {
        if (true === $this->error_mode)
        {
            $types = [
                'string' => ['string', 'str'],
                'integer' => ['integer', 'integer+', 'integer-', 'int', 'int+', 'int-']
            ];
            
            if (isset($types[$getTypeResult]) && (in_array($expected, $types[$getTypeResult])))
            {
            
            }
            else
            {
                $strTemp = "Type does not match! '%s' is not %s. [%s].";
                $this->writeInfoToLogfile(
                    sprintf(
                        $strTemp,
                        $name,
                        $expected,
                        $getTypeResult
                    )
                );
            }
        }
    }
     
    protected function writeInfoToLogfile(string $sMessage=""): void
    {
        $sOutputStrg = "[".date("Y-m-d H:i:s")."] ".$sMessage."\n";
        $sFullPath = dirname(__DIR__, 2).$this->logFilePath.$this->logFileName;
        file_put_contents($sFullPath, $sOutputStrg, FILE_APPEND);
    }
}