590 lines
15 KiB
PHP
590 lines
15 KiB
PHP
<?php
|
||
/*-------------------------------------------------------
|
||
*
|
||
* LiveStreet Engine Social Networking
|
||
* Copyright © 2008 Mzhelskiy Maxim
|
||
*
|
||
*--------------------------------------------------------
|
||
*
|
||
* Official site: www.livestreet.ru
|
||
* Contact e-mail: rus.engine@gmail.com
|
||
*
|
||
* GNU General Public License, version 2:
|
||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
||
*
|
||
---------------------------------------------------------
|
||
*/
|
||
|
||
/**
|
||
* Если не стоит расширения mb
|
||
*
|
||
* @param unknown_type $s
|
||
* @return unknown
|
||
*/
|
||
if (!function_exists('mb_strlen')) {
|
||
function mb_strlen($s, $sEncode = "UTF-8")
|
||
{
|
||
$length = strlen(iconv($sEncode, 'Windows-1251', $s));
|
||
return (int)$length;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Если не стоит расширения mb
|
||
*/
|
||
if (!function_exists('mb_strtolower')) {
|
||
function mb_strtolower($s, $sEncode = "UTF-8")
|
||
{
|
||
$s = iconv($sEncode, "Windows-1251", $s);
|
||
$s = strtolower($s);
|
||
$s = iconv("Windows-1251", $sEncode, $s);
|
||
return $s;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Проверяет запрос послан как ajax или нет
|
||
* Пришлось продублировать здесь, чтобы получить к ней доступ до подключения роутера
|
||
*
|
||
* @return unknown
|
||
*/
|
||
function isAjaxRequest()
|
||
{
|
||
return isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_X_REQUESTED_WITH'] === 'XMLHttpRequest';
|
||
}
|
||
|
||
/**
|
||
* функция вывода отладочных сообщений через консоль браузера
|
||
*/
|
||
function dump()
|
||
{
|
||
Engine::getInstance()->Logger_Console(func_get_args());
|
||
}
|
||
|
||
|
||
/**
|
||
* функция доступа к GET POST параметрам
|
||
*
|
||
* @param string $sName
|
||
* @param mixed $default
|
||
* @param string $sType
|
||
* @return mixed
|
||
*/
|
||
function getRequest($sName, $default = null, $sType = null)
|
||
{
|
||
/**
|
||
* Выбираем в каком из суперглобальных искать указанный ключ
|
||
*/
|
||
switch (strtolower($sType)) {
|
||
default:
|
||
case null:
|
||
$aStorage = $_REQUEST;
|
||
break;
|
||
case 'get':
|
||
$aStorage = $_GET;
|
||
break;
|
||
case 'post':
|
||
$aStorage = $_POST;
|
||
break;
|
||
}
|
||
|
||
if (isset($aStorage[$sName])) {
|
||
if (is_string($aStorage[$sName])) {
|
||
return trim($aStorage[$sName]);
|
||
} else {
|
||
return $aStorage[$sName];
|
||
}
|
||
}
|
||
return $default;
|
||
}
|
||
|
||
/**
|
||
* функция доступа к GET POST параметрам, которая значение принудительно приводит к строке
|
||
*
|
||
* @param string $sName
|
||
* @param mixed $default
|
||
* @param string $sType
|
||
*
|
||
* @return string
|
||
*/
|
||
function getRequestStr($sName, $default = null, $sType = null)
|
||
{
|
||
$mData = getRequest($sName, $default, $sType);
|
||
if (!is_array($mData)) {
|
||
return (string)$mData;
|
||
}
|
||
return '';
|
||
}
|
||
|
||
/**
|
||
* Определяет был ли передан указанный параметр методом POST
|
||
*
|
||
* @param string|null $sName
|
||
* @return bool
|
||
*/
|
||
function isPost($sName=null)
|
||
{
|
||
if (is_null($sName)) {
|
||
return $_SERVER['REQUEST_METHOD'] == 'POST';
|
||
}
|
||
return (getRequest($sName, null, 'post') !== null);
|
||
}
|
||
|
||
/**
|
||
* генерирует случайную последовательность символов
|
||
*
|
||
* @param unknown_type $iLength
|
||
* @return unknown
|
||
*/
|
||
function func_generator($iLength = 10)
|
||
{
|
||
if ($iLength > 32) {
|
||
$iLength = 32;
|
||
}
|
||
return substr(md5(uniqid(mt_rand(), true)), 0, $iLength);
|
||
}
|
||
|
||
/**
|
||
* htmlspecialchars умеющая обрабатывать массивы
|
||
*
|
||
* @param mixed $data
|
||
* @param int %walkIndex - represents the key/index of the array being recursively htmlspecialchars'ed
|
||
* @return void
|
||
*/
|
||
function func_htmlspecialchars(&$data, $walkIndex = null)
|
||
{
|
||
if (is_string($data)) {
|
||
$data = htmlspecialchars($data);
|
||
} elseif (is_array($data)) {
|
||
array_walk($data, __FUNCTION__);
|
||
}
|
||
}
|
||
|
||
function func_urlspecialchars_array(&$data, $walkIndex = null)
|
||
{
|
||
if (is_string($data)) {
|
||
$data = func_urlspecialchars($data);
|
||
} elseif (is_array($data)) {
|
||
array_walk($data, __FUNCTION__);
|
||
}
|
||
}
|
||
|
||
function func_urlspecialchars($data)
|
||
{
|
||
$aTable = get_html_translation_table();
|
||
unset($aTable['&']);
|
||
return strtr($data, $aTable);
|
||
}
|
||
|
||
/**
|
||
* stripslashes умеющая обрабатывать массивы
|
||
*
|
||
* @param unknown_type $data
|
||
*/
|
||
function func_stripslashes(&$data)
|
||
{
|
||
if (is_array($data)) {
|
||
foreach ($data as $sKey => $value) {
|
||
if (is_array($value)) {
|
||
func_stripslashes($data[$sKey]);
|
||
} else {
|
||
$data[$sKey] = stripslashes($value);
|
||
}
|
||
}
|
||
} else {
|
||
$data = stripslashes($data);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Проверяет на корректность значение соглавно правилу
|
||
*
|
||
* @param unknown_type $sValue
|
||
* @param unknown_type $sParam
|
||
* @param unknown_type $iMin
|
||
* @param unknown_type $iMax
|
||
* @return unknown
|
||
*/
|
||
function func_check($sValue, $sParam, $iMin = 1, $iMax = 100)
|
||
{
|
||
if (is_array($sValue)) {
|
||
return false;
|
||
}
|
||
switch ($sParam) {
|
||
case 'id':
|
||
if (preg_match("/^\d{" . $iMin . ',' . $iMax . "}$/", $sValue)) {
|
||
return true;
|
||
}
|
||
break;
|
||
case 'float':
|
||
if (preg_match("/^[\-]?\d+[\.]?\d*$/", $sValue)) {
|
||
return true;
|
||
}
|
||
break;
|
||
case 'mail':
|
||
if (preg_match("/^[\da-z\_\-\.\+]+@[\da-z_\-\.]+\.[a-z]{2,5}$/i", $sValue)) {
|
||
return true;
|
||
}
|
||
break;
|
||
case 'login':
|
||
if (preg_match("/^[\da-z\_\-]{" . $iMin . ',' . $iMax . "}$/i", $sValue)) {
|
||
return true;
|
||
}
|
||
break;
|
||
case 'md5':
|
||
if (preg_match("/^[\da-z]{32}$/i", $sValue)) {
|
||
return true;
|
||
}
|
||
break;
|
||
case 'password':
|
||
if (mb_strlen($sValue, 'UTF-8') >= $iMin) {
|
||
return true;
|
||
}
|
||
break;
|
||
case 'text':
|
||
if (mb_strlen($sValue, 'UTF-8') >= $iMin and mb_strlen($sValue, 'UTF-8') <= $iMax) {
|
||
return true;
|
||
}
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Шифрование
|
||
*
|
||
* @param unknown_type $sData
|
||
* @return unknown
|
||
*/
|
||
function func_encrypt($sData)
|
||
{
|
||
return md5($sData);
|
||
}
|
||
|
||
|
||
/**
|
||
* Определяет IP адрес
|
||
*
|
||
* @return unknown
|
||
*/
|
||
function func_getIp()
|
||
{
|
||
// Если запускаем через консоль, то REMOTE_ADDR не определен
|
||
return isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '127.0.0.1';
|
||
}
|
||
|
||
|
||
/**
|
||
* Заменяет стандартную header('Location: *');
|
||
*
|
||
* @param unknown_type $sLocation
|
||
*/
|
||
function func_header_location($sLocation)
|
||
{
|
||
$sProtocol = isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.1';
|
||
header("{$sProtocol} 301 Moved Permanently");
|
||
header('Location: ' . $sLocation);
|
||
exit();
|
||
}
|
||
|
||
/**
|
||
* Создаёт каталог по полному пути
|
||
*
|
||
* @param unknown_type $sBasePath
|
||
* @param unknown_type $sNewDir
|
||
*/
|
||
function func_mkdir($sBasePath, $sNewDir)
|
||
{
|
||
$sDirToCheck = rtrim($sBasePath, '/') . '/' . $sNewDir;
|
||
if (!is_dir($sDirToCheck)) {
|
||
@mkdir($sDirToCheck, 0755, true);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Рекурсивное удаление директории (со всем содержимым)
|
||
*
|
||
* @param string $sPath
|
||
* @return bool
|
||
*/
|
||
function func_rmdir($sPath)
|
||
{
|
||
if (!is_dir($sPath)) {
|
||
return true;
|
||
}
|
||
$sPath = rtrim($sPath, '/');
|
||
|
||
$aFiles = array_diff(scandir($sPath), array('.', '..'));
|
||
foreach ($aFiles as $sFile) {
|
||
(is_dir("$sPath/$sFile")) ? func_rmdir("$sPath/$sFile") : @unlink("$sPath/$sFile");
|
||
}
|
||
return @rmdir($sPath);
|
||
}
|
||
|
||
/**
|
||
* Возвращает обрезанный текст по заданное число слов
|
||
*
|
||
* @param unknown_type $sText
|
||
* @param unknown_type $iCountWords
|
||
*/
|
||
function func_text_words($sText, $iCountWords)
|
||
{
|
||
$aWords = preg_split('#[\s\r\n]+#um', $sText);
|
||
if ($iCountWords < count($aWords)) {
|
||
$aWords = array_slice($aWords, 0, $iCountWords);
|
||
}
|
||
return join(' ', $aWords);
|
||
}
|
||
|
||
/**
|
||
* Меняет числовые ключи массива на их значения
|
||
*
|
||
* @param unknown_type $arr
|
||
* @param unknown_type $sDefValue
|
||
*/
|
||
function func_array_simpleflip(&$arr, $sDefValue = 1)
|
||
{
|
||
foreach ($arr as $key => $value) {
|
||
if (is_int($key) and is_string($value)) {
|
||
unset($arr[$key]);
|
||
$arr[$value] = $sDefValue;
|
||
}
|
||
}
|
||
}
|
||
|
||
function func_build_cache_keys($array, $sBefore = '', $sAfter = '')
|
||
{
|
||
$aRes = array();
|
||
foreach ($array as $key => $value) {
|
||
$aRes[$value] = $sBefore . $value . $sAfter;
|
||
}
|
||
return $aRes;
|
||
}
|
||
|
||
function func_array_sort_by_keys($array, $aKeys)
|
||
{
|
||
$aResult = array();
|
||
foreach ($aKeys as $iKey) {
|
||
if (isset($array[$iKey])) {
|
||
$aResult[$iKey] = $array[$iKey];
|
||
}
|
||
}
|
||
return $aResult;
|
||
}
|
||
|
||
/**
|
||
* Сливает два ассоциативных массива
|
||
*
|
||
* @param unknown_type $aArr1
|
||
* @param unknown_type $aArr2
|
||
* @return unknown
|
||
*/
|
||
function func_array_merge_assoc($aArr1, $aArr2)
|
||
{
|
||
$aRes = $aArr1;
|
||
foreach ($aArr2 as $k2 => $v2) {
|
||
$bIsKeyInt = false;
|
||
if (is_array($v2)) {
|
||
foreach ($v2 as $k => $v) {
|
||
if (is_int($k)) {
|
||
$bIsKeyInt = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (is_array($v2) and !$bIsKeyInt and isset($aArr1[$k2])) {
|
||
$aRes[$k2] = func_array_merge_assoc($aArr1[$k2], $v2);
|
||
} else {
|
||
$aRes[$k2] = $v2;
|
||
}
|
||
}
|
||
return $aRes;
|
||
}
|
||
|
||
if (!function_exists('array_fill_keys')) {
|
||
function array_fill_keys($aArr, $values)
|
||
{
|
||
if (!is_array($aArr)) {
|
||
$aArr = array($aArr);
|
||
}
|
||
$aArrOut = array();
|
||
foreach ($aArr as $key => $value) {
|
||
$aArrOut[$value] = $values;
|
||
}
|
||
return $aArrOut;
|
||
}
|
||
}
|
||
|
||
if (!function_exists('array_intersect_key')) {
|
||
function array_intersect_key($isec, $keys)
|
||
{
|
||
$argc = func_num_args();
|
||
if ($argc > 2) {
|
||
for ($i = 1; !empty($isec) && $i < $argc; $i++) {
|
||
$arr = func_get_arg($i);
|
||
foreach (array_keys($isec) as $key) {
|
||
if (!isset($arr[$key])) {
|
||
unset($isec[$key]);
|
||
}
|
||
}
|
||
}
|
||
return $isec;
|
||
} else {
|
||
$res = array();
|
||
foreach (array_keys($isec) as $key) {
|
||
if (isset($keys[$key])) {
|
||
$res[$key] = $isec[$key];
|
||
}
|
||
}
|
||
return $res;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!function_exists('class_alias')) {
|
||
function class_alias($original, $alias)
|
||
{
|
||
if (!class_exists($original)) {
|
||
return false;
|
||
}
|
||
eval('abstract class ' . $alias . ' extends ' . $original . ' {}');
|
||
return true;
|
||
}
|
||
}
|
||
|
||
|
||
function func_underscore($sStr)
|
||
{
|
||
return strtolower(preg_replace('/([^A-Z])([A-Z])/', "$1_$2", (string) $sStr));
|
||
}
|
||
|
||
function func_camelize($sStr)
|
||
{
|
||
$aParts = explode('_', $sStr);
|
||
$sCamelized = '';
|
||
foreach ($aParts as $sPart) {
|
||
$sCamelized .= ucfirst($sPart);
|
||
}
|
||
return $sCamelized;
|
||
}
|
||
|
||
|
||
function func_list_plugins($bAll = false)
|
||
{
|
||
$sPluginsDir = Config::Get('path.application.plugins.server');
|
||
$sPluginsListFile = $sPluginsDir . '/' . Config::Get('sys.plugins.activation_file');
|
||
$aPlugin = array();
|
||
if ($bAll) {
|
||
$aPluginRaw = array();
|
||
$aPaths = glob("$sPluginsDir/*", GLOB_ONLYDIR);
|
||
if ($aPaths) {
|
||
foreach ($aPaths as $sPath) {
|
||
$aPluginRaw[] = basename($sPath);
|
||
}
|
||
}
|
||
} else {
|
||
if ($aPluginRaw = @file($sPluginsListFile)) {
|
||
$aPluginRaw = array_map('trim', $aPluginRaw);
|
||
$aPluginRaw = array_unique($aPluginRaw);
|
||
}
|
||
}
|
||
if ($aPluginRaw) {
|
||
foreach ($aPluginRaw as $sPlugin) {
|
||
$sPluginXML = "$sPluginsDir/$sPlugin/plugin.xml";
|
||
if (is_file($sPluginXML)) {
|
||
$aPlugin[] = $sPlugin;
|
||
}
|
||
}
|
||
}
|
||
return $aPlugin;
|
||
}
|
||
|
||
function func_convert_entity_to_array(Entity $oEntity, $aMethods = null, $sPrefix = '')
|
||
{
|
||
if (!is_array($aMethods)) {
|
||
$aMethods = get_class_methods($oEntity);
|
||
}
|
||
$aEntity = array();
|
||
foreach ($aMethods as $sMethod) {
|
||
if (!preg_match('#^get([a-z][a-z\d]*)$#i', $sMethod, $aMatch)) {
|
||
continue;
|
||
}
|
||
$sProp = strtolower(preg_replace('#([a-z])([A-Z])#', '$1_$2', $aMatch[1]));
|
||
$mValue = call_user_func(array($oEntity, $sMethod));
|
||
$aEntity[$sPrefix . $sProp] = $mValue;
|
||
}
|
||
return $aEntity;
|
||
}
|
||
|
||
function func_method_exists($mObject, $sMethod, $sType = null)
|
||
{
|
||
$oRef = new ReflectionClass($mObject);
|
||
if ($oRef->hasMethod($sMethod)) {
|
||
if (is_null($sType)) {
|
||
return true;
|
||
}
|
||
$oMethod = $oRef->getMethod($sMethod);
|
||
switch ($sType) {
|
||
case "static":
|
||
return $oMethod->isStatic();
|
||
break;
|
||
case "public":
|
||
return $oMethod->isPublic();
|
||
break;
|
||
case "protected":
|
||
return $oMethod->isProtected();
|
||
break;
|
||
case "private":
|
||
return $oMethod->isPrivate();
|
||
break;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function func_array_unshift_assoc(&$aArr, $sKey, $mVal)
|
||
{
|
||
$aArr = array_reverse($aArr, true);
|
||
$aArr[$sKey] = $mVal;
|
||
$aArr = array_reverse($aArr, true);
|
||
}
|
||
|
||
function func_ini_return_bytes($sSizeStr)
|
||
{
|
||
switch (substr($sSizeStr, -1)) {
|
||
case 'M':
|
||
case 'm':
|
||
return (int)$sSizeStr * 1048576;
|
||
case 'K':
|
||
case 'k':
|
||
return (int)$sSizeStr * 1024;
|
||
case 'G':
|
||
case 'g':
|
||
return (int)$sSizeStr * 1073741824;
|
||
default:
|
||
return $sSizeStr;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Позволяет получить значение объекта в многомерном массиве задав путь до него
|
||
*
|
||
* @param array $aArr Массив с данными, например: [ "user" => [ "name" => "John", "id" => 15 ] ]
|
||
* @param array $aKeys Путь до объекта, например: [ "user", "name" ]
|
||
* @return mixed Значение параметра, путь до которого указан в $aKeys
|
||
*/
|
||
function func_array_multisearch($aArr, $aKeys)
|
||
{
|
||
$mTemp = $aArr;
|
||
|
||
foreach ($aKeys as $mKey) {
|
||
if (!isset($mTemp[$mKey])) return false;
|
||
|
||
$mTemp = $mTemp[$mKey];
|
||
}
|
||
|
||
return $mTemp;
|
||
}
|