/**
* Constructs a SiteUrl object from request variables
*
* @param HttpUrlDictionary $dictionary dictionary of values to be used in building the SiteUrl
* @param string $baseHost optional host to be treated as base host
* @param string $baseUri optional uri to be treated as base uri
*
* @return SiteUrl
*/
static function import(HttpUrlDictionary $dictionary, $baseHost = null, $baseUri = '/')
{
$url = new self();
if ($baseHost) {
$url->setBaseHost($baseHost);
}
$url->setBasePath($baseUri);
$url->setScheme($dictionary->getField(HttpUrlDictionary::HTTPS) ? 'https' : 'http')->setHost($dictionary->getField(HttpUrlDictionary::HOST))->setPort($dictionary->getField(HttpUrlDictionary::PORT));
//get the URI itself
$uri = $dictionary->getField(HttpUrlDictionary::URI);
if (!preg_match('/^https?:\\/\\//', $uri)) {
$uri = '/' . ltrim($uri, '/');
}
$parts = parse_url($uri);
if (isset($parts['path'])) {
$path = urldecode($parts['path']);
$url->setPath($path);
}
if (isset($parts['query'])) {
$newQuery = $query = array();
parse_str($parts['query'], $query);
foreach ($query as $k => $v) {
$newQuery[urldecode($k)] = is_array($v) ? $v : urldecode($v);
}
$url->setQuery($newQuery);
}
return $url;
}
/**
* Constructs a SiteUrl object from request variables
*
* @return SiteUrl
*/
static function import($scheme, $host, $port, $uri, $baseHost = null, $baseUri = '/')
{
$url = new self();
if ($baseHost) {
$url->setBaseHost($baseHost);
}
$url->setBasePath($baseUri);
$url->setScheme($scheme)->setHost($host)->setPort($port);
//get the URI itself
if (!preg_match('/^https?:\\/\\//', $uri)) {
$uri = '/' . ltrim($uri, '/');
}
$parts = parse_url($uri);
if (isset($parts['path'])) {
$path = urldecode($parts['path']);
$url->setPath($path);
}
if (isset($parts['query'])) {
$newQuery = $query = array();
parse_str($parts['query'], $query);
foreach ($query as $k => $v) {
$newQuery[urldecode($k)] = is_array($v) ? $v : urldecode($v);
}
$url->setQuery($newQuery);
}
return $url;
}
public function addThumb($maxDim, $folder)
{
$thumb = new self();
$thumb->setPath($this->getFolderPath());
$thumb->setMaxDim($maxDim);
$thumb->setFolder($folder);
$this->thumbs[$folder] = $thumb;
}
/**
* @param Schema $schema
* @param Property $property
* @param string $operationType
* @return Operation
*/
public static function factory(Schema $schema, Property $property, $operationType)
{
$operation = new self();
$operation->setType($operationType);
$operation->setSchema($schema);
$operation->setPath($property->getPath());
$operation->setValue($property->getValue());
return $operation;
}
public static function byPath($_pathfile)
{
if (!file_exists($_pathfile)) {
throw new Exception('Chemin jusqu\'au widget non trouvé : ' . $_pathfile);
}
$path_parts = pathinfo($_pathfile);
$informations = explode('.', $path_parts['basename']);
$widget = new self();
$widget->setType($informations[1]);
$widget->setSubtype($informations[2]);
$widget->setName($informations[3]);
$folder = explode('/', $path_parts['dirname']);
$widget->setVersion($folder[count($folder) - 1]);
$widget->setContent(file_get_contents($_pathfile));
$widget->setPath($_pathfile);
return $widget;
}
/**
* @return Request
*/
public static function fromInput()
{
global $module;
$model = new self();
$model->setMethod(self::getMethodFromInput());
if (isset($module)) {
$model->setPath($module);
$input = explode('/', $module);
$model->setSegments($input);
}
$model->setBody(InputStream::getInput());
$model->setHeaders(self::getHeadersFromInput());
$model->setParameters($_GET);
$model->setCookies($_COOKIE);
$model->setPost($_POST);
$model->setEnvironment($_SERVER);
$model->setStatus(http_response_code());
$model->setUrl(self::getCurrentUri());
$model->parseData();
return $model;
}
/**
* @param CategoryEntity $category
* @return Category
*/
public static function createFromCategoryEntity(CategoryEntity $category)
{
$struct = new self();
$struct->setId($category->getId());
$struct->setName($category->getName());
$struct->setPosition($category->getPosition());
$struct->setParentId($category->getParentId());
$path = $category->getPath();
if ($path) {
$path = ltrim($path, '|');
$path = rtrim($path, '|');
$path = explode('|', $path);
$struct->setPath(array_reverse($path));
}
return $struct;
}
/**
* @param wfWAFRequest|null $request
* @return wfWAFRequest
*/
public static function createFromGlobals($request = null)
{
if ($request === null) {
if (version_compare(phpversion(), '5.3.0') > 0) {
$class = get_called_class();
$request = new $class();
} else {
$request = new self();
}
}
$request->setAuth(array());
$request->setCookies(array());
$request->setFileNames(array());
$request->setFiles(array());
$request->setHeaders(array());
$request->setHost('');
$request->setIP('');
$request->setMethod('');
$request->setPath('');
$request->setProtocol('');
$request->setTimestamp('');
$request->setURI('');
$request->setBody(wfWAFUtils::stripMagicQuotes($_POST));
$request->setQueryString(wfWAFUtils::stripMagicQuotes($_GET));
$request->setCookies(wfWAFUtils::stripMagicQuotes($_COOKIE));
$request->setFiles(wfWAFUtils::stripMagicQuotes($_FILES));
if (!empty($_FILES)) {
$fileNames = array();
foreach ($_FILES as $input => $file) {
$fileNames[$input] = wfWAFUtils::stripMagicQuotes($file['name']);
}
$request->setFileNames($fileNames);
}
if (is_array($_SERVER)) {
//All of these depend on $_SERVER being non-null and an array
$auth = array();
if (array_key_exists('PHP_AUTH_USER', $_SERVER)) {
$auth['user'] = wfWAFUtils::stripMagicQuotes($_SERVER['PHP_AUTH_USER']);
}
if (array_key_exists('PHP_AUTH_PW', $_SERVER)) {
$auth['password'] = wfWAFUtils::stripMagicQuotes($_SERVER['PHP_AUTH_PW']);
}
$request->setAuth($auth);
if (array_key_exists('REQUEST_TIME_FLOAT', $_SERVER)) {
$timestamp = $_SERVER['REQUEST_TIME_FLOAT'];
} else {
if (array_key_exists('REQUEST_TIME', $_SERVER)) {
$timestamp = $_SERVER['REQUEST_TIME'];
} else {
$timestamp = time();
}
}
$request->setTimestamp($timestamp);
$headers = array();
foreach ($_SERVER as $key => $value) {
if (wfWAFUtils::strpos($key, 'HTTP_') === 0) {
$header = wfWAFUtils::substr($key, 5);
$header = str_replace(array(' ', '_'), array('', ' '), $header);
$header = ucwords(wfWAFUtils::strtolower($header));
$header = str_replace(' ', '-', $header);
$headers[$header] = wfWAFUtils::stripMagicQuotes($value);
}
}
if (array_key_exists('CONTENT_TYPE', $_SERVER)) {
$headers['Content-Type'] = wfWAFUtils::stripMagicQuotes($_SERVER['CONTENT_TYPE']);
}
if (array_key_exists('CONTENT_LENGTH', $_SERVER)) {
$headers['Content-Length'] = wfWAFUtils::stripMagicQuotes($_SERVER['CONTENT_LENGTH']);
}
$request->setHeaders($headers);
$host = '';
if (array_key_exists('Host', $headers)) {
$host = $headers['Host'];
} else {
if (array_key_exists('SERVER_NAME', $_SERVER)) {
$host = wfWAFUtils::stripMagicQuotes($_SERVER['SERVER_NAME']);
}
}
$request->setHost($host);
$request->setMethod(array_key_exists('REQUEST_METHOD', $_SERVER) ? wfWAFUtils::stripMagicQuotes($_SERVER['REQUEST_METHOD']) : 'GET');
$request->setProtocol(array_key_exists('HTTPS', $_SERVER) && $_SERVER['HTTPS'] && $_SERVER['HTTPS'] !== 'off' ? 'https' : 'http');
$request->setUri(array_key_exists('REQUEST_URI', $_SERVER) ? wfWAFUtils::stripMagicQuotes($_SERVER['REQUEST_URI']) : '');
$uri = parse_url($request->getURI());
if (is_array($uri) && array_key_exists('path', $uri)) {
$path = $uri['path'];
} else {
$path = $request->getURI();
}
$request->setPath($path);
}
return $request;
}
/**
* Creates a CronJobDefinition from a Array $job
* provided by the parser $parser
*
* @param Array $xml
* @param CronJobParser $parser
*
* @return CronJobDefinition
*/
public static function fromArray(array $job, CronJobParser $parser)
{
// create and return object
$obj = new self();
$obj->setParser($parser);
$obj->setName($job["name"]);
$obj->setForkable((bool) $job["forkable"]);
$obj->setInterval($job["interval"]);
$obj->setPath($job["path"]);
$obj->setClass($job["class"]);
$obj->setStartTime($job["starttime"]);
$obj->setEndTime($job["endtime"]);
$obj->setArguments($job["args"]);
$obj->setWeekDays($job["weekdays"]);
$obj->setSuspended((bool) $job["suspended"]);
if (isset($job["lastrun"])) {
$obj->setLastExec($job["lastrun"]);
} else {
$obj->setLastExec(0);
}
return $obj;
}
/**
* Creates a cookie object from a string
*
* @param string The cookie string
* @return Woops_Http_Cookie The cookie object
* @throws Woops_Http_Cookie_Exception If the cookie string cannot be parsed
*/
public static function createCookieObject($str)
{
// Finds the position of the first '=' character
$equal = strpos($str, '=');
// Checks for the '=' character
if (!$equal) {
// Invalid cookie - No '=' character
throw new Woops_Http_Cookie_Exception('Invalid cookie: \'' . $str . '\'', Woops_Http_Cookie_Exception::EXCEPTION_BAD_COOKIE);
}
// Gets the cookie's name
$name = trim(substr($str, 0, $equal));
// Gets the cookie options
$options = trim(substr($str, $equal + 1));
// Gets the cookie's options' parts
$parts = explode(';', $options);
// Gets the cookie valie
$value = trim(array_shift($parts));
// Creates the cookie object
$cookie = new self($name, $value);
// Process each part
foreach ($parts as $part) {
// Position of the '=' character
$equal = strpos($part, '=');
// Checks for the '=' character
if (!$equal) {
// Option without a value
$name = trim($part);
} else {
// Gets the name and the value of the option
$name = trim(substr($part, 0, $equal));
$value = trim(substr($part, $equal + 1));
}
// Checks the option name
switch ($name) {
// Expiration date
case 'expires':
// Sets the expiration date (as a timestamp)
$cookie->setExpires(strtotime($value));
break;
// Path
// Path
case 'path':
// Sets the cookie's path
$cookie->setPath($value);
break;
// Domain
// Domain
case 'domain':
// Sets the cookie's domain
$cookie->setDomain($value);
break;
// Secure option
// Secure option
case 'secure':
// The cookie is secure
$cookie->setSecure(true);
break;
// HTTP only option
// HTTP only option
case 'HttpOnly':
// The cookie is accessible only through the HTTP protocol
$cookie->setHttpOnly(true);
break;
// Unknown option
// Unknown option
default:
break;
}
}
// Returns the cookie object
return $cookie;
}
/**
* Factory method to use when creating a new torrent object
*
* @param string $type
* @param array $params
* @return Zend_BitTorrent_Torrent
* @throws Zend_BitTorrent_Torrent_Exception
*/
public static function factory($type, $params = array())
{
if ($params !== null && !is_array($params)) {
/** @see Zend_BitTorrent_Torrent_Exception */
require_once 'Zend/BitTorrent/Torrent/Exception.php';
throw new Zend_BitTorrent_Torrent_Exception('$params must either be null or an array.');
}
$torrent = new self();
if ($type === self::CREATE_FROM_FILE) {
if (!isset($params['file'])) {
/** @see Zend_BitTorrent_Torrent_Exception */
require_once 'Zend/BitTorrent/Torrent/Exception.php';
throw new Zend_BitTorrent_Torrent_Exception('Missing "file" parameter.');
}
$torrent->setTorrentFilePath($params['file']);
$torrent->buildFromTorrent();
} else {
if ($type === self::CREATE_FROM_PATH) {
if (!isset($params['path']) || !isset($params['announce'])) {
/** @see Zend_BitTorrent_Torrent_Exception */
require_once 'Zend/BitTorrent/Torrent/Exception.php';
throw new Zend_BitTorrent_Torrent_Exception('Missing "path" and/or "announce" parameters.');
}
$torrent->setPath($params['path'])->setAnnounce($params['announce'])->buildFromPath();
} else {
if ($type === self::CREATE_NEW) {
/* Do nothing */
} else {
/** @see Zend_BitTorrent_Torrent_Exception */
require_once 'Zend/BitTorrent/Torrent/Exception.php';
throw new Zend_BitTorrent_Torrent_Exception('Invalid type.');
}
}
}
return $torrent;
}
/**
* Create a new template instance using path and extension from current instance
*
* @param string $template Template name
* @param array $variables Template variables
*
* @return $this
*/
public function template($template, $variables = [])
{
$instance = new self();
$instance->setPath($this->path);
$instance->setExtension($this->extension);
$instance->setTemplate($template);
$instance->setVariables($variables);
return $instance;
}
/**
* @param ShopEntity $shop
* @return Shop
*/
public static function createFromShopEntity(ShopEntity $shop)
{
$struct = new self();
$struct->setId($shop->getId());
$struct->setParentId($shop->getMain() ? $shop->getMain()->getId() : $shop->getId());
$struct->setIsDefault($shop->getDefault());
$struct->setName($shop->getName());
$struct->setHost($shop->getHost());
$struct->setPath($shop->getBasePath());
$struct->setUrl($shop->getBaseUrl());
$struct->setSecure($shop->getSecure());
$struct->setSecureHost($shop->getSecureHost());
$struct->setSecurePath($shop->getSecureBasePath());
if ($shop->getCategory()) {
$struct->setCategory(Category::createFromCategoryEntity($shop->getCategory()));
}
if ($shop->getFallback()) {
$struct->setFallbackId($shop->getFallback()->getId());
}
return $struct;
}
/**
* Builds a new URI object from server environment
*
* @param array $environment Server environment (e.g. $_SERVER)
* @return Uri
*/
public static function fromEnvironment(array $environment)
{
$uri = new self();
$uri->setScheme(isset($environment['HTTPS']) && ($environment['HTTPS'] == 'on' || $environment['HTTPS'] == 1) || isset($environment['HTTP_X_FORWARDED_PROTO']) && $environment['HTTP_X_FORWARDED_PROTO'] == 'https' ? 'https' : 'http');
$uri->setHostname($environment['HTTP_HOST']);
$uri->setPort(isset($environment['SERVER_PORT']) ? (int) $environment['SERVER_PORT'] : NULL);
$uri->setUsername(isset($environment['PHP_AUTH_USER']) ? $environment['PHP_AUTH_USER'] : NULL);
$uri->setPassword(isset($environment['PHP_AUTH_PW']) ? $environment['PHP_AUTH_PW'] : NULL);
$requestUriParts = explode('?', $environment['REQUEST_URI'], 2);
$uri->setPath($requestUriParts[0]);
if (isset($requestUriParts[1])) {
$queryParts = explode('#', $requestUriParts[1], 2);
$uri->setQuery($queryParts[0]);
$uri->setFragment(isset($queryParts[1]) ? $queryParts[1] : NULL);
}
return $uri;
}
/**
* Generate a new Cookie object from a cookie string
* (for example the value of the Set-Cookie HTTP header)
*
* @static
* @throws Zend_Http_Header_Exception_InvalidArgumentException
* @param $headerLine
* @param bool $bypassHeaderFieldName
* @return array|SetCookie
*/
public static function fromString($headerLine, $bypassHeaderFieldName = false)
{
list($name, $value) = explode(': ', $headerLine, 2);
// check to ensure proper header type for this factory
if (strtolower($name) !== 'set-cookie') {
throw new Zend_Http_Header_Exception_InvalidArgumentException('Invalid header line for Set-Cookie string: "' . $name . '"');
}
$multipleHeaders = preg_split('#(?<!Sun|Mon|Tue|Wed|Thu|Fri|Sat),\\s*#', $value);
$headers = array();
foreach ($multipleHeaders as $headerLine) {
$header = new self();
$keyValuePairs = preg_split('#;\\s*#', $headerLine);
foreach ($keyValuePairs as $keyValue) {
if (strpos($keyValue, '=')) {
list($headerKey, $headerValue) = preg_split('#=\\s*#', $keyValue, 2);
} else {
$headerKey = $keyValue;
$headerValue = null;
}
// First K=V pair is always the cookie name and value
if ($header->getName() === NULL) {
$header->setName($headerKey);
$header->setValue($headerValue);
continue;
}
// Process the remanining elements
switch (str_replace(array('-', '_'), '', strtolower($headerKey))) {
case 'expires':
$header->setExpires($headerValue);
break;
case 'domain':
$header->setDomain($headerValue);
break;
case 'path':
$header->setPath($headerValue);
break;
case 'secure':
$header->setSecure(true);
break;
case 'httponly':
$header->setHttponly(true);
break;
case 'version':
$header->setVersion((int) $headerValue);
break;
case 'maxage':
$header->setMaxAge((int) $headerValue);
break;
default:
// Intentionally omitted
}
}
$headers[] = $header;
}
return count($headers) == 1 ? array_pop($headers) : $headers;
}
/**
* Convert a Windows file path to a valid file:// URL
*
* @param string $path
* @return File
*/
public static function fromWindowsPath($path)
{
$url = new self('file:');
// Convert directory separators
$path = str_replace(array('/', '\\'), array('%2F', '/'), $path);
// Is this an absolute path?
if (preg_match('|^([a-zA-Z]:)?/|', $path)) {
$url->setHost('');
}
$url->setPath($path);
return $url;
}
/**
* Fabric method creator
*
* @param string $path
* @return afExtjsBuilderParser
* @author Sergey Startsev
*/
public static function create($path = '')
{
$instance = new self();
$instance->setPath($path);
return $instance;
}
