Erkan IŞIK
556 lines
12 KiB
PHP
556 lines
12 KiB
PHP
<?php namespace ZN\Request;
|
|
/**
|
|
* ZN PHP Web Framework
|
|
*
|
|
* "Simplicity is the ultimate sophistication." ~ Da Vinci
|
|
*
|
|
* @package ZN
|
|
* @license MIT [http://opensource.org/licenses/MIT]
|
|
* @author Ozan UYKUN [ozan@znframework.com]
|
|
*/
|
|
|
|
use ZN\In;
|
|
use ZN\IS;
|
|
use ZN\Lang;
|
|
use ZN\Base;
|
|
use ZN\Request;
|
|
use ZN\Security;
|
|
use ZN\DataTypes\Arrays;
|
|
use ZN\DataTypes\Strings;
|
|
|
|
class URI implements URIInterface
|
|
{
|
|
/**
|
|
* Keeps data.
|
|
*
|
|
* @param array
|
|
*/
|
|
protected static $data = NULL;
|
|
|
|
/**
|
|
* Magic Call
|
|
*
|
|
* @param string $method
|
|
* @param array $parameters
|
|
*
|
|
* @return string|int
|
|
*/
|
|
public function __call($method, $parameters)
|
|
{
|
|
if( preg_match('/^(e|s)([0-9]+)$/', $method) )
|
|
{
|
|
$typ = $method[0];
|
|
$num = $method[1];
|
|
$val = $typ === 's' ? $num : -($num);
|
|
|
|
$return = self::segment($val, ...$parameters);
|
|
}
|
|
else
|
|
{
|
|
$return = self::get($method, ...$parameters);
|
|
}
|
|
|
|
if( $method[0] == 'X' )
|
|
{
|
|
$m = substr($method, 1);
|
|
|
|
return explode('?', self::$m(...$parameters))[0];
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Data usage.
|
|
*
|
|
* @param string|array $data
|
|
*
|
|
* @return self
|
|
*/
|
|
public static function data($data) : URI
|
|
{
|
|
if( is_string($data) )
|
|
{
|
|
$data = explode('/', Base::removePrefix($data));
|
|
}
|
|
|
|
self::$data = $data;
|
|
|
|
return new self;
|
|
}
|
|
|
|
/**
|
|
* Manipulation
|
|
*
|
|
* @param array $rules
|
|
* @param string $type = 'none' - options[none|left|right|both]
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function manipulation(array $rules, string $type = 'none') : string
|
|
{
|
|
$query = '';
|
|
|
|
foreach( $rules as $key => $value )
|
|
{
|
|
if( is_numeric($key) )
|
|
{
|
|
if( ! empty($val = self::get($value)) )
|
|
{
|
|
|
|
$query .= $value . '/' . $val . '/';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$query .= $key . '/' . $value . '/';
|
|
}
|
|
}
|
|
|
|
return self::_addFix($query, $type);
|
|
}
|
|
|
|
/**
|
|
* Build Query
|
|
*
|
|
* @param array $data
|
|
* @param string $separator = '/'
|
|
* @param string $type = 'none' - options[none|left|right|both]
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function buildQuery(array $data, string $separator = '/', string $type = 'none') : string
|
|
{
|
|
$query = '';
|
|
|
|
foreach( $data as $key => $value )
|
|
{
|
|
if( is_numeric($key) )
|
|
{
|
|
$query .= $value . $separator;
|
|
}
|
|
else
|
|
{
|
|
$query .= $key . $separator . $value . $separator;
|
|
}
|
|
}
|
|
|
|
return self::_addFix($query, $type, $separator);
|
|
}
|
|
|
|
/**
|
|
* Get
|
|
*
|
|
* @param string|int $get = 1
|
|
* @param string|int $index = 1
|
|
* @param bool $while = false
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function get($get = 1, $index = 1, bool $while = false) : string
|
|
{
|
|
if( ! IS::char($index) )
|
|
{
|
|
$index = 1;
|
|
}
|
|
|
|
$segArr = self::segmentArray();
|
|
$segVal = '';
|
|
|
|
if( is_numeric($get) )
|
|
{
|
|
return self::getByIndex($get, $index, $segArr);
|
|
}
|
|
|
|
if( in_array($get, $segArr) )
|
|
{
|
|
$segVal = array_search($get, $segArr);
|
|
|
|
# 3. parameter is not empty
|
|
# 2. The non-numerical state of the parameter
|
|
if( ! empty($while) && ! is_numeric($index) )
|
|
{
|
|
return self::getByName($get, $index, $segArr);
|
|
}
|
|
|
|
# 2. the parameter is all-in
|
|
# It gives all segments from parameter 1.
|
|
if( $index === 'all' )
|
|
{
|
|
return self::getNameAll($get, $segArr);
|
|
}
|
|
|
|
# 3. parameter is not empty
|
|
if( ! empty($while) )
|
|
{
|
|
$return = '';
|
|
|
|
$countSegArr = count($segArr) - 1;
|
|
|
|
if( $index > $countSegArr )
|
|
{
|
|
$index = $countSegArr; // @codeCoverageIgnore
|
|
}
|
|
|
|
if( $index < 0 )
|
|
{
|
|
$index = $countSegArr + $index + 1; // @codeCoverageIgnore
|
|
}
|
|
|
|
for( $i = 1; $i <= $index; $i++ )
|
|
{
|
|
$return .= $segArr[$segVal + $i] . '/';
|
|
}
|
|
|
|
$return = substr($return,0,-1);
|
|
|
|
return $return;
|
|
}
|
|
|
|
# 2. the parameter is all-in
|
|
# It gives all segments from parameter 1.
|
|
if( $index === 'count' )
|
|
{
|
|
return self::getNameCount($get, $segArr);
|
|
}
|
|
|
|
if( isset($segArr[$segVal + $index]) )
|
|
{
|
|
return $segArr[$segVal + $index];
|
|
}
|
|
else
|
|
{
|
|
return false; // @codeCoverageIgnore
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the number of segments after the specified segment.
|
|
*
|
|
* @param string $get
|
|
*
|
|
* @return int
|
|
*/
|
|
public static function getNameCount(string $get, $segArr = NULL) : int
|
|
{
|
|
$segArr = $segArr ?? self::segmentArray();
|
|
|
|
if( in_array($get, $segArr) )
|
|
{
|
|
$segVal = array_search($get, $segArr);
|
|
|
|
return count($segArr) - 1 - $segVal;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns all segments after the specified segment.
|
|
*
|
|
* @param string $get
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getNameAll(string $get, $segArr = NULL) : string
|
|
{
|
|
$segArr = $segArr ?? self::segmentArray();
|
|
|
|
if( in_array($get, $segArr) )
|
|
{
|
|
$return = '';
|
|
|
|
$segVal = array_search($get, $segArr);
|
|
|
|
for( $i = 1; $i < count($segArr) - $segVal; $i++ )
|
|
{
|
|
$return .= $segArr[$segVal + $i] . '/';
|
|
}
|
|
|
|
$return = substr($return, 0, -1);
|
|
|
|
return $return;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Used to get the range according to the index of the specified segment.
|
|
*
|
|
* @param int $get = 1
|
|
* @param int $index = 1
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getByIndex(int $get = 1, int $index = 1, $segArr = NULL) : string
|
|
{
|
|
$segArr = $segArr ?? self::segmentArray();
|
|
|
|
if( $get == 0 )
|
|
{
|
|
$get = 1;
|
|
}
|
|
|
|
$get -= 1;
|
|
|
|
$countSegArr = count($segArr);
|
|
|
|
if( $index < 0 )
|
|
{
|
|
$index = $countSegArr + ($index + 1);
|
|
}
|
|
else if( $index > 0 )
|
|
{
|
|
$index = $get + $index;
|
|
|
|
if( $index > $countSegArr )
|
|
{
|
|
$index = $countSegArr;
|
|
}
|
|
}
|
|
|
|
$uri = '';
|
|
|
|
for( $i = $get; $i < $index; $i++ )
|
|
{
|
|
$uri .= $segArr[$i].'/';
|
|
}
|
|
|
|
return rtrim($uri, '/');
|
|
}
|
|
|
|
/**
|
|
* Used to get the range according to the specified segment names.
|
|
*
|
|
* @param string $get
|
|
* @param mixed $index = NULL
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getByName(string $get, $index = NULL, $segArr = NULL) : string
|
|
{
|
|
$segArr = $segArr ?? self::segmentArray();
|
|
|
|
$getVal = (int) array_search($get, $segArr);
|
|
|
|
if( $index === 'all' )
|
|
{
|
|
$indexVal = count($segArr) - 1;
|
|
}
|
|
else if( $index === NULL )
|
|
{
|
|
return $segArr[array_search($get, $segArr) + 1] ?? '';
|
|
}
|
|
else
|
|
{
|
|
$indexVal = array_search($index, $segArr);
|
|
}
|
|
|
|
$return = '';
|
|
|
|
for( $i = $getVal; $i <= $indexVal; $i++ )
|
|
{
|
|
$return .= $segArr[$i] . '/';
|
|
}
|
|
|
|
return substr($return, 0, -1);
|
|
}
|
|
|
|
/**
|
|
* Get Segment Array
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function segmentArray() : array
|
|
{
|
|
$segmentEx = self::$data ?? Arrays\RemoveElement::element(explode('/', self::_cleanPath()), '');
|
|
|
|
self::$data = NULL;
|
|
|
|
return $segmentEx;
|
|
}
|
|
|
|
/**
|
|
* Get Total Segments
|
|
*
|
|
* @return int
|
|
*/
|
|
public static function totalSegments() : int
|
|
{
|
|
$segmentEx = array_diff(self::segmentArray(), ['', ' ']);
|
|
$totalSegments = count($segmentEx);
|
|
|
|
return $totalSegments;
|
|
}
|
|
|
|
/**
|
|
* Get Segment Count / Get Total Segments
|
|
*
|
|
* @return int
|
|
*/
|
|
public static function segmentCount() : int
|
|
{
|
|
return self::totalSegments();
|
|
}
|
|
|
|
/**
|
|
* Get segment
|
|
*
|
|
* @param int $set = 1
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function segment(int $seg = 1) : string
|
|
{
|
|
$segments = self::segmentArray();
|
|
|
|
if( $seg > 0 )
|
|
{
|
|
$seg -= 1;
|
|
}
|
|
elseif( $seg < 0 )
|
|
{
|
|
$count = count($segments);
|
|
$seg = $count + $seg;
|
|
}
|
|
|
|
$select = $segments[$seg] ?? false;
|
|
|
|
if( ! empty($select) )
|
|
{
|
|
return $segments[$seg];
|
|
}
|
|
elseif( $select === '0' ) // 5.3.34[added]
|
|
{
|
|
return (int) $select;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Current Segment
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function currentSegment() : string
|
|
{
|
|
return self::current(false);
|
|
}
|
|
|
|
/**
|
|
* Current
|
|
*
|
|
* @param bool $isPath = true
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function current(bool $isPath = true) : string
|
|
{
|
|
$currentPagePath = str_replace(Lang::get().'/', '', Base::currentPath());
|
|
|
|
if( ($currentPagePath[0] ?? NULL) === '/' )
|
|
{
|
|
$currentPagePath = substr($currentPagePath, 1, strlen($currentPagePath) - 1);
|
|
}
|
|
|
|
if( $isPath === true )
|
|
{
|
|
return $currentPagePath;
|
|
}
|
|
else
|
|
{
|
|
$str = explode('/', $currentPagePath);
|
|
|
|
if( count($str) > 1 )
|
|
{
|
|
return $str[count($str) - 1];
|
|
}
|
|
|
|
return $str[0]; // @codeCoverageIgnore
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get active URI
|
|
*
|
|
* @param bool $fullPath = false
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function active(bool $fullPath = false) : string
|
|
{
|
|
return Request::getActiveURI($fullPath);
|
|
}
|
|
|
|
/**
|
|
* Base
|
|
*
|
|
* @param string $uri = NULL
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function base(?string $uri = NULL) : string
|
|
{
|
|
return In::cleanInjection(BASE_DIR . $uri);
|
|
}
|
|
|
|
/**
|
|
* Prev
|
|
*
|
|
* @param bool $isPath = true
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function prev(bool $isPath = true) : string
|
|
{
|
|
if( ! isset($_SERVER['HTTP_REFERER']) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
$str = str_replace(URL::site(), '', $_SERVER['HTTP_REFERER']);
|
|
|
|
if( $isPath === true )
|
|
{
|
|
return $str;
|
|
}
|
|
else
|
|
{
|
|
return Strings\Split::divide($str, '/', -1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Protected Clean Path
|
|
*/
|
|
protected static function _cleanPath()
|
|
{
|
|
$pathInfo = Security\Html::encode(In::cleanInjection(self::active()));
|
|
|
|
return $pathInfo;
|
|
}
|
|
|
|
/**
|
|
* Protected Add Fix
|
|
*/
|
|
protected static function _addFix($query, $type, $separator = '/')
|
|
{
|
|
$query = rtrim($query, $separator);
|
|
|
|
switch( $type )
|
|
{
|
|
case 'left' : return Base::prefix($query, $separator);
|
|
case 'right' : return Base::suffix($query, $separator);
|
|
case 'both' : return Base::presuffix($query, $separator);
|
|
default : return $query;
|
|
}
|
|
}
|
|
}
|