lepton_request.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
class LEPTON_request
{
    use LEPTON_singleton;
 
    const USE_POST    = "post";
    const USE_GET     = "get";
    const USE_REQUEST = "request";
    const USE_SESSION = "session";
    const USE_SERVER  = "server";
 
    const ALLOWED_INSIDE = [
        self::USE_POST,
        self::USE_GET,
        self::USE_REQUEST,
        self::USE_SESSION,
        self::USE_SERVER
    ];
 
    public static $instance;
 
    protected 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 setStrictLookInside(string $sNewValue = ''): bool
    {
        if ($sNewValue === '')
        {
            return false;
        }
        
        $sNewValueLower = strtolower($sNewValue);
        
        if (in_array($sNewValueLower, self::ALLOWED_INSIDE))
        {
            $this->strict_looking_inside = $sNewValueLower;
            return true;
        } else {
            return false;
        }
    }
    
    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 testValues(array &$aValueList): array
    {
        $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|bool|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 ($this->strict_looking_inside) 
            {
                case self::USE_POST:
                    $return_value = $_POST[$aName] ?? $aDefault;
                    break;
                    
                case self::USE_GET:
                    $return_value = $_GET[$aName] ?? $aDefault;
                    break;
                    
                case self::USE_REQUEST:
                    $return_value = $_REQUEST[$aName] ?? $aDefault;
                    break;
                 
                case self::USE_SESSION:
                    $return_value = $_SESSION[$aName] ?? $aDefault;
                    break;
                    
                case self::USE_SERVER:
                    $return_value = $_SERVER[$aName] ?? $aDefault;
                    break;
                       
                default:
                    $return_value = null;
                    break;
            }
        }
        
        if (!empty($type)) 
        {
            // $this->testType($aName, $type, gettype($return_value));
            
            if (is_array($return_value) && ($type != "array"))
            {
                foreach ($return_value as $key => &$tempValue)
                {
                    $tempValue = $this->filterValue($tempValue, $type, $aDefault, $range);
                }
            }
            else
            {
                $return_value = $this->filterValue($return_value, $type, $aDefault, $range);
            }
        }
        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 (is_null($value))
        {
            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 'integer_eval':
            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
                    ]
                ]
            );
        }
    }
 
    public function filterValue(
        string|int|array|float|bool|null $return_value,
        string $type,
        string|int|array|float|bool|null $aDefault=null,
        string|array $range=""
    ): string|int|array|float|bool|null
    {
        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;
 
            //  [1.5] Evaluate an expression. E.g. "3 * 5" results in 15
            case 'integer_eval':
                $return_value = intval(eval("return ".$return_value.";"));
 
                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($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($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; 
 
            //  [2.5] string only with some chars, see LEPTON_core->string_secure
            case 'string_secure':      
                if (false === LEPTON_handle::checkStringSecure($return_value))
                {
                    $return_value = $aDefault;
                }
                break;
                        
            //  [4.1] E-Mail
            case 'email':
                if (!is_string($return_value))
                {
                    $return_value = $aDefault;
                }
                elseif (false === LEPTON_handle::checkEmailChars($return_value))
                {
                    $return_value = $aDefault;
                }
                break;
            
            //  [4.2] username
            case 'username':
                if (!is_string($return_value))
                {
                    $return_value = $aDefault;
                }
                elseif (false === LEPTON_handle::checkUsernameChars($return_value))
                {
                    $return_value = $aDefault;
                }
                break;
 
            //  [4.3] password      // just to check password chars, NO testing if password is valid
            case 'password':
                if (!is_string($return_value))
                {
                    $return_value = $aDefault;
                }
                elseif (false === LEPTON_handle::checkPasswordChars($return_value))
                {
                    $return_value = $aDefault;
                }
                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-d\TH: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 -- Keep in mind that this one could be problematic for recursive requests!
            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] Boolean
            case 'bool':
                $return_value = filter_var(
                        $return_value,
                        FILTER_VALIDATE_BOOLEAN,
                        ['flags' => FILTER_NULL_ON_FAILURE]
                        ) ?? $aDefault;
                break;
 
            //  [9]
            default:
                // nothing above match.
                break;
        }
 
        return $return_value;
    }
    
    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);
    }
}