mirror of
https://github.com/nuxsmin/sysPass.git
synced 2026-03-03 07:04:07 +01:00
407a3f0694
* [ADD] Mail provider. Work in progress * [MOD] Updated copyright * [MOD] Improved tracking module
783 lines
23 KiB
PHP
783 lines
23 KiB
PHP
<?php
|
|
/**
|
|
* sysPass
|
|
*
|
|
* @author nuxsmin
|
|
* @link https://syspass.org
|
|
* @copyright 2012-2018, Rubén Domínguez nuxsmin@$syspass.org
|
|
*
|
|
* This file is part of sysPass.
|
|
*
|
|
* sysPass is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* sysPass is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with sysPass. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
namespace SP\Util;
|
|
|
|
use Defuse\Crypto\Core;
|
|
use Defuse\Crypto\Encoding;
|
|
use SP\Bootstrap;
|
|
use SP\Config\Config;
|
|
use SP\Config\ConfigData;
|
|
use SP\Config\ConfigDB;
|
|
use SP\Core\Exceptions\SPException;
|
|
use SP\Core\Init;
|
|
use SP\Core\Install\Installer;
|
|
use SP\Core\Session\Session;
|
|
use SP\Core\SessionFactory;
|
|
use SP\Html\Html;
|
|
use SP\Log\Log;
|
|
use SP\Log\LogUtil;
|
|
|
|
defined('APP_ROOT') || die();
|
|
|
|
/**
|
|
* Clase con utilizades para la aplicación
|
|
*/
|
|
class Util
|
|
{
|
|
/**
|
|
* Generar una clave aleatoria
|
|
*
|
|
* @param int $length Longitud de la clave
|
|
* @param bool $useNumbers Usar números
|
|
* @param bool $useSpecial Usar carácteres especiales
|
|
* @param bool $checKStrength
|
|
* @return string
|
|
*/
|
|
public static function randomPassword($length = 16, $useNumbers = true, $useSpecial = true, $checKStrength = true)
|
|
{
|
|
$charsLower = 'abcdefghijklmnopqrstuwxyz';
|
|
$charsUpper = 'ABCDEFGHIJKLMNOPQRSTUWXYZ';
|
|
|
|
$alphabet = $charsLower . $charsUpper;
|
|
|
|
if ($useSpecial === true) {
|
|
$charsSpecial = '@$%&/()!_:.;{}^';
|
|
$alphabet .= $charsSpecial;
|
|
}
|
|
|
|
if ($useNumbers === true) {
|
|
$charsNumbers = '0123456789';
|
|
$alphabet .= $charsNumbers;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
$passGen = function () use ($alphabet, $length) {
|
|
$pass = [];
|
|
$alphaLength = strlen($alphabet) - 1; //put the length -1 in cache
|
|
|
|
for ($i = 0; $i < $length; $i++) {
|
|
$n = mt_rand(0, $alphaLength);
|
|
$pass[] = $alphabet[$n];
|
|
}
|
|
|
|
return $pass;
|
|
};
|
|
|
|
if ($checKStrength === true) {
|
|
do {
|
|
$pass = $passGen();
|
|
$strength = ['lower' => 0, 'upper' => 0, 'special' => 0, 'number' => 0];
|
|
|
|
foreach ($pass as $char) {
|
|
if (strpos($charsLower, $char) !== false) {
|
|
$strength['lower']++;
|
|
} elseif (strpos($charsUpper, $char) !== false) {
|
|
$strength['upper']++;
|
|
} elseif ($useSpecial === true && strpos($charsSpecial, $char) !== false) {
|
|
$strength['special']++;
|
|
} elseif ($useNumbers === true && strpos($charsNumbers, $char) !== false) {
|
|
$strength['number']++;
|
|
}
|
|
}
|
|
|
|
if ($useSpecial === false) {
|
|
unset($strength['special']);
|
|
}
|
|
|
|
if ($useNumbers === false) {
|
|
unset($strength['number']);
|
|
}
|
|
} while (in_array(0, $strength, true));
|
|
|
|
return implode($pass);
|
|
}
|
|
|
|
return implode($passGen());
|
|
}
|
|
|
|
/**
|
|
* Generar una cadena aleatoria usuando criptografía.
|
|
*
|
|
* @param int $length opcional, con la longitud de la cadena
|
|
* @return string
|
|
* @throws \Defuse\Crypto\Exception\EnvironmentIsBrokenException
|
|
*/
|
|
public static function generateRandomBytes($length = 30)
|
|
{
|
|
return Encoding::binToHex(Core::secureRandom($length));
|
|
}
|
|
|
|
|
|
/**
|
|
* Devuelve el valor de la variable enviada por un formulario.
|
|
*
|
|
* @param string $s con el nombre de la variable
|
|
* @param string $d con el valor por defecto
|
|
* @return string con el valor de la variable
|
|
*/
|
|
public static function init_var($s, $d = '')
|
|
{
|
|
$r = $d;
|
|
if (isset($_REQUEST[$s]) && !empty($_REQUEST[$s])) {
|
|
$r = Html::sanitize($_REQUEST[$s]);
|
|
}
|
|
|
|
return $r;
|
|
}
|
|
|
|
|
|
/**
|
|
* Devuelve la versión de sysPass.
|
|
*
|
|
* @return string con la versión
|
|
*/
|
|
public static function getVersionString()
|
|
{
|
|
return '2.2-dev';
|
|
}
|
|
|
|
/**
|
|
* Comprobar si hay actualizaciones de sysPass disponibles desde internet (github.com)
|
|
* Esta función hace una petición a GitHub y parsea el JSON devuelto para verificar
|
|
* si la aplicación está actualizada
|
|
*
|
|
* @return array|bool
|
|
*/
|
|
public static function checkUpdates()
|
|
{
|
|
try {
|
|
$data = self::getDataFromUrl(self::getAppInfo('appupdates'));
|
|
} catch (SPException $e) {
|
|
return false;
|
|
}
|
|
|
|
$updateInfo = json_decode($data);
|
|
|
|
if (!isset($updateInfo->message)) {
|
|
// $updateInfo[0]->tag_name
|
|
// $updateInfo[0]->name
|
|
// $updateInfo[0]->body
|
|
// $updateInfo[0]->tarball_url
|
|
// $updateInfo[0]->zipball_url
|
|
// $updateInfo[0]->published_at
|
|
// $updateInfo[0]->html_url
|
|
|
|
$version = $updateInfo->tag_name;
|
|
$url = $updateInfo->html_url;
|
|
$title = $updateInfo->name;
|
|
$description = $updateInfo->body;
|
|
$date = $updateInfo->published_at;
|
|
|
|
preg_match('/v?(\d+)\.(\d+)\.(\d+)\.(\d+)(\-[a-z0-9.]+)?$/', $version, $remoteVersion);
|
|
// preg_match('/v?(\d+)\.(\d+)\.(\d+)(\-[a-z0-9.]+)?$/', $version, $realVer);
|
|
|
|
if (is_array($remoteVersion)) {
|
|
$appVersion = self::getVersionStringNormalized();
|
|
$pubVersion = $remoteVersion[1] . $remoteVersion[2] . $remoteVersion[3] . '.' . $remoteVersion[4];
|
|
// $pubVersion = $realVer[1] . $realVer[2] . $realVer[3];
|
|
|
|
if (self::checkVersion($appVersion, $pubVersion)) {
|
|
return [
|
|
'version' => $version,
|
|
'url' => $url,
|
|
'title' => $title,
|
|
'description' => $description,
|
|
'date' => $date];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Obtener datos desde una URL usando CURL
|
|
*
|
|
* @param string $url
|
|
* @param array $data
|
|
* @param bool|null $useCookie
|
|
* @param bool $weak
|
|
* @return bool|string
|
|
* @throws \Psr\Container\NotFoundExceptionInterface
|
|
* @throws \Psr\Container\ContainerExceptionInterface
|
|
* @throws SPException
|
|
*/
|
|
public static function getDataFromUrl($url, array $data = null, $useCookie = false, $weak = false)
|
|
{
|
|
/** @var ConfigData $ConfigData */
|
|
$ConfigData = Bootstrap::getContainer()->get(ConfigData::class);
|
|
|
|
if (!Checks::curlIsAvailable()) {
|
|
$Log = LogUtil::extensionNotLoaded('CURL', __FUNCTION__);
|
|
|
|
throw new SPException($Log->getDescription(), SPException::WARNING);
|
|
}
|
|
|
|
$ch = curl_init($url);
|
|
|
|
if ($ConfigData->isProxyEnabled()) {
|
|
curl_setopt($ch, CURLOPT_PROXY, $ConfigData->getProxyServer());
|
|
curl_setopt($ch, CURLOPT_PROXYPORT, $ConfigData->getProxyPort());
|
|
curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
|
|
|
|
$proxyUser = $ConfigData->getProxyUser();
|
|
|
|
if ($proxyUser) {
|
|
$proxyAuth = $proxyUser . ':' . $ConfigData->getProxyPass();
|
|
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyAuth);
|
|
}
|
|
}
|
|
|
|
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
|
|
curl_setopt($ch, CURLOPT_HEADER, false);
|
|
curl_setopt($ch, CURLINFO_HEADER_OUT, true);
|
|
curl_setopt($ch, CURLOPT_USERAGENT, 'sysPass-App');
|
|
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
|
|
curl_setopt($ch, CURLOPT_TIMEOUT, 60);
|
|
|
|
if ($weak === true) {
|
|
// Trust SSL enabled server
|
|
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
|
|
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
|
|
}
|
|
|
|
if (null !== $data) {
|
|
curl_setopt($ch, CURLOPT_POST, 1);
|
|
curl_setopt($ch, CURLOPT_HTTPHEADER, $data['type']);
|
|
curl_setopt($ch, CURLOPT_POSTFIELDS, $data['data']);
|
|
}
|
|
|
|
if ($useCookie) {
|
|
$cookie = self::getUserCookieFile();
|
|
|
|
if ($cookie) {
|
|
if (!SessionFactory::getCurlCookieSession()) {
|
|
curl_setopt($ch, CURLOPT_COOKIESESSION, true);
|
|
curl_setopt($ch, CURLOPT_COOKIEJAR, $cookie);
|
|
|
|
SessionFactory::setCurlCookieSession(true);
|
|
}
|
|
|
|
curl_setopt($ch, CURLOPT_COOKIEFILE, $cookie);
|
|
}
|
|
}
|
|
|
|
$data = curl_exec($ch);
|
|
|
|
$httpStatus = curl_getinfo($ch, CURLINFO_HTTP_CODE);
|
|
|
|
if ($data === false || $httpStatus !== 200) {
|
|
$Log = new Log();
|
|
$LogMessgae = $Log->getLogMessage();
|
|
$LogMessgae->setAction(__FUNCTION__);
|
|
$LogMessgae->addDescription(curl_error($ch));
|
|
$LogMessgae->addDetails(__('Respuesta', false), $httpStatus);
|
|
$Log->setLogLevel(Log::ERROR);
|
|
$Log->writeLog();
|
|
|
|
throw new SPException($LogMessgae->getDescription(), SPException::WARNING);
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Devuelve el nombre de archivo a utilizar para las cookies del usuario
|
|
*
|
|
* @return string|false
|
|
*/
|
|
public static function getUserCookieFile()
|
|
{
|
|
$tempDir = self::getTempDir();
|
|
|
|
return $tempDir ? $tempDir . DIRECTORY_SEPARATOR . md5('syspass-' . SessionFactory::getUserData()->getLogin()) : false;
|
|
}
|
|
|
|
/**
|
|
* Comprueba y devuelve un directorio temporal válido
|
|
*
|
|
* @return bool|string
|
|
*/
|
|
public static function getTempDir()
|
|
{
|
|
$sysTmp = sys_get_temp_dir();
|
|
$appTmp = Init::$SERVERROOT . DIRECTORY_SEPARATOR . 'tmp';
|
|
$file = 'syspass.test';
|
|
|
|
$checkDir = function ($dir) use ($file) {
|
|
if (file_exists($dir . DIRECTORY_SEPARATOR . $file)) {
|
|
return $dir;
|
|
}
|
|
|
|
if (is_dir($dir) || @mkdir($dir)) {
|
|
if (touch($dir . DIRECTORY_SEPARATOR . $file)) {
|
|
return $dir;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
if ($checkDir($appTmp)) {
|
|
return $appTmp;
|
|
}
|
|
|
|
return $checkDir($sysTmp);
|
|
}
|
|
|
|
/**
|
|
* Devuelve información sobre la aplicación.
|
|
*
|
|
* @param string $index con la key a devolver
|
|
* @return array|string con las propiedades de la aplicación
|
|
*/
|
|
public static function getAppInfo($index = null)
|
|
{
|
|
$appinfo = [
|
|
'appname' => 'sysPass',
|
|
'appdesc' => 'Systems Password Manager',
|
|
'appalias' => 'SPM',
|
|
'appwebsite' => 'https://www.syspass.org',
|
|
'appblog' => 'https://www.cygnux.org',
|
|
'appdoc' => 'https://doc.syspass.org',
|
|
'appupdates' => 'https://api.github.com/repos/nuxsmin/sysPass/releases/latest',
|
|
'appnotices' => 'https://api.github.com/repos/nuxsmin/sysPass/issues?milestone=none&state=open&labels=Notices',
|
|
'apphelp' => 'https://github.com/nuxsmin/sysPass/issues',
|
|
'appchangelog' => 'https://github.com/nuxsmin/sysPass/blob/master/CHANGELOG'
|
|
];
|
|
|
|
if (null !== $index && isset($appinfo[$index])) {
|
|
return $appinfo[$index];
|
|
}
|
|
|
|
return $appinfo;
|
|
}
|
|
|
|
/**
|
|
* Devolver versión normalizada en cadena
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getVersionStringNormalized()
|
|
{
|
|
return implode('', Installer::VERSION) . '.' . Installer::BUILD;
|
|
}
|
|
|
|
/**
|
|
* Comprobar si una versión necesita actualización
|
|
*
|
|
* @param string $currentVersion
|
|
* @param array|string $upgradeableVersion
|
|
* @return bool True si la versión es menor.
|
|
*/
|
|
public static function checkVersion($currentVersion, $upgradeableVersion)
|
|
{
|
|
if (is_array($upgradeableVersion)) {
|
|
$upgradeableVersion = $upgradeableVersion[count($upgradeableVersion) - 1];
|
|
}
|
|
|
|
$currentVersion = self::normalizeVersionForCompare($currentVersion);
|
|
$upgradeableVersion = self::normalizeVersionForCompare($upgradeableVersion);
|
|
|
|
if (PHP_INT_SIZE > 4) {
|
|
return version_compare($currentVersion, $upgradeableVersion) === -1;
|
|
}
|
|
|
|
list($currentVersion, $build) = explode('.', $currentVersion, 2);
|
|
list($upgradeVersion, $upgradeBuild) = explode('.', $upgradeableVersion, 2);
|
|
|
|
$versionRes = (int)$currentVersion <= (int)$upgradeVersion;
|
|
|
|
return (($versionRes && (int)$upgradeBuild === 0)
|
|
|| ($versionRes && (int)$build < (int)$upgradeBuild));
|
|
}
|
|
|
|
/**
|
|
* Devuelve una versión normalizada para poder ser comparada
|
|
*
|
|
* @param string $versionIn
|
|
* @return string
|
|
*/
|
|
private static function normalizeVersionForCompare($versionIn)
|
|
{
|
|
if (is_string($versionIn) && !empty($versionIn)) {
|
|
list($version, $build) = explode('.', $versionIn);
|
|
|
|
$nomalizedVersion = 0;
|
|
|
|
foreach (str_split($version) as $key => $value) {
|
|
$nomalizedVersion += (int)$value * (10 ** (3 - $key));
|
|
}
|
|
|
|
return $nomalizedVersion . '.' . $build;
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Devuelve la versión de sysPass.
|
|
*
|
|
* @param bool $retBuild devolver el número de compilación
|
|
*
|
|
* @return array con el número de versión
|
|
*/
|
|
public static function getVersionArray($retBuild = false)
|
|
{
|
|
$version = array_values(Installer::VERSION);
|
|
|
|
if ($retBuild === true) {
|
|
$version[] = Installer::BUILD;
|
|
|
|
return $version;
|
|
}
|
|
|
|
return $version;
|
|
}
|
|
|
|
/**
|
|
* Devolver versión normalizada en array
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getVersionArrayNormalized()
|
|
{
|
|
return [implode('', Installer::VERSION), Installer::BUILD];
|
|
}
|
|
|
|
/**
|
|
* Comprobar si hay notificaciones de sysPass disponibles desde internet (github.com)
|
|
* Esta función hace una petición a GitHub y parsea el JSON devuelto
|
|
*
|
|
* @return array|bool
|
|
* @throws \Psr\Container\ContainerExceptionInterface
|
|
*/
|
|
public static function checkNotices()
|
|
{
|
|
/** @var ConfigData $ConfigData */
|
|
$ConfigData = Bootstrap::getContainer()->get(ConfigData::class);
|
|
|
|
if (!$ConfigData->isChecknotices()) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
$data = self::getDataFromUrl(self::getAppInfo('appnotices'));
|
|
} catch (SPException $e) {
|
|
return false;
|
|
}
|
|
|
|
$noticesData = json_decode($data);
|
|
|
|
|
|
if (!isset($noticesData->message)) {
|
|
$notices = [];
|
|
|
|
// $noticesData[0]->title
|
|
// $noticesData[0]->body
|
|
// $noticesData[0]->created_at
|
|
|
|
foreach ($noticesData as $notice) {
|
|
$notices[] = [
|
|
$notice->title,
|
|
// $notice->body,
|
|
$notice->created_at
|
|
];
|
|
}
|
|
|
|
return $notices;
|
|
}
|
|
|
|
debugLog($noticesData->message);
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Realiza el proceso de logout.
|
|
*/
|
|
public static function logout()
|
|
{
|
|
exit('<script>sysPassApp.actions().main.logout();</script>');
|
|
}
|
|
|
|
/**
|
|
* Obtener el tamaño máximo de subida de PHP.
|
|
*/
|
|
public static function getMaxUpload()
|
|
{
|
|
$max_upload = (int)ini_get('upload_max_filesize');
|
|
$max_post = (int)ini_get('post_max_size');
|
|
$memory_limit = (int)ini_get('memory_limit');
|
|
|
|
return min($max_upload, $max_post, $memory_limit);
|
|
}
|
|
|
|
/**
|
|
* Checks a variable to see if it should be considered a boolean true or false.
|
|
* Also takes into account some text-based representations of true of false,
|
|
* such as 'false','N','yes','on','off', etc.
|
|
*
|
|
* @author Samuel Levy <sam+nospam@samuellevy.com>
|
|
* @param mixed $in The variable to check
|
|
* @param bool $strict If set to false, consider everything that is not false to
|
|
* be true.
|
|
* @return bool The boolean equivalent or null (if strict, and no exact equivalent)
|
|
*/
|
|
public static function boolval($in, $strict = false)
|
|
{
|
|
$in = (is_string($in) ? strtolower($in) : $in);
|
|
|
|
// if not strict, we only have to check if something is false
|
|
if (in_array($in, array('false', 'no', 'n', '0', 'off', false, 0), true) || !$in) {
|
|
return false;
|
|
}
|
|
|
|
if ($strict && in_array($in, array('true', 'yes', 'y', '1', 'on', true, 1), true)) {
|
|
return true;
|
|
}
|
|
|
|
// not strict? let the regular php bool check figure it out (will
|
|
// largely default to true)
|
|
return ($in ? true : false);
|
|
}
|
|
|
|
/**
|
|
* Establecer variable de sesión para recargar la aplicación.
|
|
*/
|
|
public static function reload()
|
|
{
|
|
if (SessionFactory::getReload() === false) {
|
|
SessionFactory::setReload(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Comprobar si se necesita recargar la aplicación.
|
|
*/
|
|
public static function checkReload()
|
|
{
|
|
if (SessionFactory::getReload() === true) {
|
|
SessionFactory::setReload(false);
|
|
exit('<script>location.reload();</script>');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Recorrer un array y escapar los carácteres no válidos en Javascript.
|
|
*
|
|
* @param $array
|
|
* @return array
|
|
*/
|
|
public static function arrayJSEscape(&$array)
|
|
{
|
|
array_walk($array, function (&$value, $index) {
|
|
$value = str_replace(['\'', '"'], '\\\'', $value);
|
|
});
|
|
return $array;
|
|
}
|
|
|
|
/**
|
|
* Obtener la URL de acceso al servidor
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getServerUrl()
|
|
{
|
|
$urlScheme = Checks::httpsEnabled() ? 'https://' : 'http://';
|
|
$urlPort = ((int)$_SERVER['SERVER_PORT'] !== 443) ? ':' . $_SERVER['SERVER_PORT'] : '';
|
|
|
|
return $urlScheme . $_SERVER['SERVER_NAME'] . $urlPort;
|
|
}
|
|
|
|
/**
|
|
* Cast an object to another class, keeping the properties, but changing the methods
|
|
*
|
|
* @param string $class Class name
|
|
* @param string|object $serialized
|
|
* @param string $srcClass Nombre de la clase serializada
|
|
* @return mixed
|
|
* @link http://blog.jasny.net/articles/a-dark-corner-of-php-class-casting/
|
|
*/
|
|
public static function unserialize($class, $serialized, $srcClass = null)
|
|
{
|
|
if (!is_object($serialized)) {
|
|
preg_match('/^O:\d+:"(?P<class>[^"]++)"/', $serialized, $matches);
|
|
|
|
if (class_exists($matches['class'])) {
|
|
return unserialize($serialized);
|
|
}
|
|
|
|
// Si se indica la clase origen, se elimina el nombre
|
|
// de la clase en los métodos privados
|
|
if ($srcClass !== null) {
|
|
$serializedOut = preg_replace_callback(
|
|
'/:\d+:"\x00' . preg_quote($srcClass, '/') . '\x00(\w+)"/',
|
|
function ($matches) {
|
|
return ':' . strlen($matches[1]) . ':"' . $matches[1] . '"';
|
|
},
|
|
$serialized);
|
|
|
|
return self::castToClass($serializedOut, $class);
|
|
}
|
|
|
|
if ($matches['class'] !== $class) {
|
|
return self::castToClass($serialized, $class);
|
|
}
|
|
}
|
|
|
|
return $serialized;
|
|
}
|
|
|
|
/**
|
|
* Cast an object to another class
|
|
*
|
|
* @param $object
|
|
* @param $class
|
|
* @return mixed
|
|
*/
|
|
public static function castToClass($object, $class)
|
|
{
|
|
// should avoid '__PHP_Incomplete_Class'?
|
|
|
|
if (is_object($object)) {
|
|
return unserialize(preg_replace('/^O:\d+:"[^"]++"/', 'O:' . strlen($class) . ':"' . $class . '"', serialize($object)));
|
|
}
|
|
|
|
return unserialize(preg_replace('/^O:\d+:"[^"]++"/', 'O:' . strlen($class) . ':"' . $class . '"', $object));
|
|
}
|
|
|
|
/**
|
|
* Devuelve la última función llamada tras un error
|
|
*
|
|
* @param string $function La función utilizada como base
|
|
* @return string
|
|
*/
|
|
public static function traceLastCall($function = null)
|
|
{
|
|
$backtrace = debug_backtrace(0);
|
|
|
|
if (count($backtrace) === 1) {
|
|
return $backtrace[1]['function'];
|
|
}
|
|
|
|
foreach ($backtrace as $index => $fn) {
|
|
if ($fn['function'] === $function) {
|
|
return $backtrace[$index + 1]['function'];
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Bloquear la aplicación
|
|
*
|
|
* @param bool $setMaintenance
|
|
*/
|
|
public static function lockApp($setMaintenance = true)
|
|
{
|
|
ConfigDB::setValue('lock', SessionFactory::getUserData()->getId(), false);
|
|
|
|
/** @var Config $Config */
|
|
$Config = Bootstrap::getContainer()['config'];
|
|
|
|
if ($setMaintenance) {
|
|
$Config->getConfigData()->setMaintenance(true);
|
|
$Config->saveConfig(null, false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Desbloquear la aplicación
|
|
*
|
|
* @param bool $unsetMaintenance
|
|
*/
|
|
public static function unlockApp($unsetMaintenance = true)
|
|
{
|
|
ConfigDB::setValue('lock', 0, false);
|
|
|
|
/** @var Config $Config */
|
|
$Config = Bootstrap::getContainer()['config'];
|
|
|
|
if ($unsetMaintenance) {
|
|
$Config->getConfigData()->setMaintenance(false);
|
|
$Config->saveConfig(null, false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Comprueba si la aplicación está bloqueada
|
|
*
|
|
* @return int
|
|
*/
|
|
public static function getAppLock()
|
|
{
|
|
return (int)ConfigDB::getValue('lock', 0);
|
|
}
|
|
|
|
/**
|
|
* Devolver el tiempo aproximado en segundos de una operación
|
|
*
|
|
* @param $startTime
|
|
* @param $numItems
|
|
* @param $totalItems
|
|
*
|
|
* @return array Con el tiempo estimado y los elementos por segundo
|
|
*/
|
|
public static function getETA($startTime, $numItems, $totalItems)
|
|
{
|
|
if ($numItems > 0 && $totalItems > 0) {
|
|
$runtime = time() - $startTime;
|
|
$eta = (int)((($totalItems * $runtime) / $numItems) - $runtime);
|
|
|
|
return [$eta, $numItems / $runtime];
|
|
}
|
|
|
|
return [0, 0];
|
|
}
|
|
|
|
/**
|
|
* Comprobar si el usuario está logado.
|
|
*
|
|
* @param Session $session
|
|
* @return bool
|
|
* @internal param Database $db
|
|
*/
|
|
public static function isLoggedIn(Session $session)
|
|
{
|
|
$userData = $session->getUserData();
|
|
|
|
return ($userData->getLogin()
|
|
&& is_object($userData->getPreferences()));
|
|
}
|
|
}
|