1669 lignes
49 KiB
PHP
1669 lignes
49 KiB
PHP
<?php
|
|
|
|
/**
|
|
* This Software is the property of Data Development and is protected
|
|
* by copyright law - it is NOT Freeware.
|
|
*
|
|
* Any unauthorized use of this software without a valid license
|
|
* is a violation of the license agreement and will be prosecuted by
|
|
* civil and criminal law.
|
|
*
|
|
* https://www.d3data.de
|
|
*
|
|
* @copyright (C) D3 Data Development (Inh. Thomas Dartsch)
|
|
* @author D3 Data Development - Daniel Seifert <support@shopmodule.com>
|
|
* @link http://www.oxidmodule.com
|
|
*/
|
|
|
|
namespace D3\ModCfg\Application\Model\Log;
|
|
|
|
use D3\ModCfg\Application\Model\d3bitmask;
|
|
use D3\ModCfg\Application\Model\d3database;
|
|
use D3\ModCfg\Application\Model\Configuration\d3_cfg_mod;
|
|
use D3\ModCfg\Application\Model\Parametercontainer\Registry as D3ModCfgRegistry;
|
|
use D3\ModCfg\Application\Model\Exception\d3ShopCompatibilityAdapterException;
|
|
use D3\ModCfg\Application\Model\Exception\d3_cfg_mod_exception;
|
|
use D3\ModCfg\Modules\Application\Controller\d3_oxshopcontrol_modcfg_extension;
|
|
use DateTimeImmutable;
|
|
use Doctrine\DBAL\Connection;
|
|
use Doctrine\DBAL\Driver\Exception as DBALDriverException;
|
|
use Doctrine\DBAL\Query\QueryBuilder;
|
|
use Exception;
|
|
use OxidEsales\Eshop\Application\Model\Shop;
|
|
use OxidEsales\Eshop\Core\ConfigFile;
|
|
use OxidEsales\Eshop\Core\Exception\StandardException;
|
|
use OxidEsales\Eshop\Core\Registry;
|
|
use OxidEsales\Eshop\Core\Request;
|
|
use OxidEsales\Eshop\Core\Model\BaseModel;
|
|
use OxidEsales\Eshop\Core\Email;
|
|
use OxidEsales\Eshop\Core\ShopControl;
|
|
use OxidEsales\Eshop\Core\Exception\DatabaseConnectionException;
|
|
use OxidEsales\Eshop\Core\Exception\DatabaseErrorException;
|
|
use Doctrine\DBAL\Exception as DBALException;
|
|
use OxidEsales\EshopCommunity\Internal\Container\ContainerFactory;
|
|
use OxidEsales\EshopCommunity\Internal\Framework\Database\ConnectionProviderInterface;
|
|
use OxidEsales\EshopCommunity\Internal\Framework\Database\QueryBuilderFactoryInterface;
|
|
use Psr\Container\ContainerExceptionInterface;
|
|
use Psr\Container\NotFoundExceptionInterface;
|
|
use Psr\Log\LoggerInterface;
|
|
use Psr\Log\LoggerTrait;
|
|
|
|
class d3log extends BaseModel implements d3LogInterface, LoggerInterface
|
|
{
|
|
use LoggerTrait;
|
|
|
|
// single log levels
|
|
public const EMERGENCY = d3LogLevel::EMERGENCY; // Int 0, Bit 1
|
|
public const ALERT = d3LogLevel::ALERT; // Int 1, Bit 2
|
|
public const CRITICAL = d3LogLevel::CRITICAL; // Int 2, Bit 4
|
|
public const ERROR = d3LogLevel::ERROR; // Int 3 Bit 8
|
|
public const WARNING = d3LogLevel::WARNING; // Int 4 Bit 16
|
|
public const NOTICE = d3LogLevel::NOTICE; // Int 5 Bit 32
|
|
public const INFO = d3LogLevel::INFO; // Int 6 Bit 64
|
|
public const DEBUG = d3LogLevel::DEBUG; // Int 7 Bit 128
|
|
public const TEST = d3LogLevel::TEST; // Int 8 Bit 256
|
|
public const NONE = d3LogLevel::NONE; // Int 12 Bit 4096
|
|
|
|
// ranged log levels
|
|
public const ERROR_AND_ABOVE = d3LogLevel::ERROR_AND_ABOVE; // Bit 15;
|
|
public const WARNING_AND_ABOVE = d3LogLevel::WARNING_AND_ABOVE; // Bit 31;
|
|
public const NOTICE_AND_ABOVE = d3LogLevel::NOTICE_AND_ABOVE; // Bit 63;
|
|
public const INFO_AND_ABOVE = d3LogLevel::INFO_AND_ABOVE; // Bit 127;
|
|
public const ALL = d3LogLevel::ALL; // Bit 4095 // accept 3 additional levels
|
|
|
|
public $aLogTypes = [
|
|
'EMERGENCY' => d3LogLevel::EMERGENCY,
|
|
'ALERT' => d3LogLevel::ALERT,
|
|
'CRITICAL' => d3LogLevel::CRITICAL,
|
|
'ERROR' => d3LogLevel::ERROR,
|
|
'WARNING' => d3LogLevel::WARNING,
|
|
'NOTICE' => d3LogLevel::NOTICE,
|
|
'INFO' => d3LogLevel::INFO,
|
|
'DEBUG' => d3LogLevel::DEBUG,
|
|
'TEST' => d3LogLevel::TEST,
|
|
];
|
|
|
|
public $aLogGroups = [
|
|
'info' => [
|
|
'INFO' => true,
|
|
'NOTICE' => true,
|
|
'WARNING' => true,
|
|
'EMERGENCY' => true,
|
|
'ALERT' => true,
|
|
'CRITICAL' => true,
|
|
'ERROR' => true,
|
|
],
|
|
'notice' => [
|
|
'NOTICE' => true,
|
|
'WARNING' => true,
|
|
'EMERGENCY' => true,
|
|
'ALERT' => true,
|
|
'CRITICAL' => true,
|
|
'ERROR' => true,
|
|
],
|
|
'warning' => [
|
|
'WARNING' => true,
|
|
'EMERGENCY' => true,
|
|
'ALERT' => true,
|
|
'CRITICAL' => true,
|
|
'ERROR' => true,
|
|
],
|
|
'error' => [
|
|
'EMERGENCY' => true,
|
|
'ALERT' => true,
|
|
'CRITICAL' => true,
|
|
'ERROR' => true,
|
|
],
|
|
'none' => [
|
|
],
|
|
];
|
|
|
|
/**
|
|
* Object registry provides storage for shared objects
|
|
*
|
|
* @var array
|
|
*/
|
|
protected static $_aRegistry = [];
|
|
|
|
protected $_blStandAloneUse = false; // set this, if other libraries aren't available
|
|
protected $_sClassName = self::class;
|
|
|
|
protected $_sCoreTbl = 'd3log'; // bc
|
|
protected $_sCoreTable = 'd3log';
|
|
|
|
protected static $_sD3CoreTable = 'd3log';
|
|
|
|
public $_iLogType = d3LogLevel::EMERGENCY;
|
|
|
|
private string $_sLogSetId = 'd3modcfg_lib';
|
|
|
|
public $sModID;
|
|
|
|
public $sProfileID;
|
|
|
|
public $aD3TypeList = [];
|
|
|
|
public $aD3ModIdList = [];
|
|
|
|
public $aD3ClassList = [];
|
|
|
|
protected $_aSkipSaveFields = ['oxcounter', 'oxtimestamp'];
|
|
|
|
protected $_iInfoMailLogMessageLength = 40;
|
|
|
|
public $pwrsearchval;
|
|
|
|
/**
|
|
* Adds a new variable to the Registry.
|
|
*
|
|
* @param string $key Name of the variable
|
|
* @param mixed $value Value of the variable
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function set($key, $value)
|
|
{
|
|
self::$_aRegistry[$key] = $value;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Tests if given $key exists in registry
|
|
*
|
|
* @param string $key
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function has($key)
|
|
{
|
|
return isset(self::$_aRegistry[$key]);
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the specified $key in the Registry.
|
|
*
|
|
* @param string $sModId
|
|
* @param int|null $iLogType
|
|
*
|
|
* @return d3log|false
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
public static function get(string $sModId, ?int $iLogType = null)
|
|
{
|
|
if (Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
startProfile(__METHOD__);
|
|
}
|
|
|
|
if (! self::isCallable()) {
|
|
return false;
|
|
}
|
|
|
|
if (self::has($sModId)) {
|
|
if (Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
|
|
return self::$_aRegistry[$sModId];
|
|
} else {
|
|
/** @var d3log $oLog */
|
|
$oLog =oxNew(d3log::class, $sModId);
|
|
|
|
if ($iLogType === false) {
|
|
$iLogType = $oLog->getLogType();
|
|
}
|
|
$oLog->setModId($sModId);
|
|
$oLog->setLogType($iLogType);
|
|
self::set($sModId, $oLog);
|
|
|
|
if (Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
|
|
return self::$_aRegistry[$sModId];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the whole Registry as an array.
|
|
*
|
|
* @return array Whole Registry
|
|
*/
|
|
public static function getAll()
|
|
{
|
|
return self::$_aRegistry;
|
|
}
|
|
|
|
/**
|
|
* Removes a variable from the Registry.
|
|
*
|
|
* @param string $key Name of the variable
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function remove($key)
|
|
{
|
|
if (self::has($key)) {
|
|
unset(self::$_aRegistry[$key]);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Removes all variables from the Registry.
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function removeAll()
|
|
{
|
|
self::$_aRegistry = [];
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* constructor
|
|
*/
|
|
public function __construct()
|
|
{
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
startProfile(__METHOD__);
|
|
}
|
|
parent::__construct();
|
|
|
|
$this->init($this->_sCoreTable);
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param string $sModId
|
|
*
|
|
* @return d3log
|
|
*/
|
|
public function setModId($sModId)
|
|
{
|
|
$this->sModID = $sModId;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function d3getModId()
|
|
{
|
|
return $this->sModID;
|
|
}
|
|
|
|
/**
|
|
* @param string $sProfileId
|
|
*
|
|
* @return d3log
|
|
*/
|
|
public function setProfileId($sProfileId)
|
|
{
|
|
$this->sProfileID = $sProfileId;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function d3getProfileId()
|
|
{
|
|
return $this->sProfileID;
|
|
}
|
|
|
|
/**
|
|
* getLogType(d3log::INFO)
|
|
* getLogType(d3log::INFO, d3log::ERROR);
|
|
*
|
|
* @param int $iLogType1
|
|
* @param int|null $iLogType2
|
|
* @param int|null $iLogType3
|
|
*
|
|
* @return d3log
|
|
*/
|
|
public function setLogType($iLogType1, $iLogType2 = null, $iLogType3 = null)
|
|
{
|
|
$aArgs = func_get_args();
|
|
$bitmask = oxNew(d3bitmask::class);
|
|
|
|
unset($iLogType1);
|
|
unset($iLogType2);
|
|
unset($iLogType3);
|
|
|
|
$aLog = [];
|
|
foreach ($aArgs as $iLogType) {
|
|
// espacially for combined logtypes
|
|
foreach ($this->aLogTypes as $iGenLogType) {
|
|
if ($bitmask->isBitSet($iLogType, $this->getLogBit($iGenLogType))) {
|
|
$aLog[$this->getErrorModeName($iGenLogType)] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count($aLog)) {
|
|
$this->_iLogType = $this->getLogTypeByArray($aLog);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param int $range
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getLogTypeListByRange($range = d3LogLevel::ALL)
|
|
{
|
|
$bitmask = oxNew(d3bitmask::class);
|
|
|
|
$types = [];
|
|
foreach ($this->aLogTypes as $iGenLogType) {
|
|
if ($bitmask->isBitSet($range, $this->getLogBit($iGenLogType))) {
|
|
$types[] = $this->getErrorModeName($iGenLogType);
|
|
}
|
|
}
|
|
|
|
return $types;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getLogType()
|
|
{
|
|
return $this->_iLogType;
|
|
}
|
|
|
|
/**
|
|
* @param int $iLogType
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param string|null $sAction
|
|
* @param string|null $mText
|
|
* @param bool $blDie
|
|
*
|
|
* @return d3log
|
|
*/
|
|
public function log(
|
|
$iLogType = d3LogLevel::EMERGENCY,
|
|
$sClass = self::class,
|
|
$sFnc = __FUNCTION__,
|
|
$iLine = __LINE__,
|
|
$sAction = null,
|
|
$mText = null,
|
|
$blDie = false
|
|
) {
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
startProfile(__METHOD__);
|
|
}
|
|
|
|
try {
|
|
$sSessID = Registry::getSession()->getId();
|
|
$this->sModID ? $sModID = $this->sModID : $sModID = 'empty';
|
|
$mText = is_string($mText) ? $mText : print_r($mText, true);
|
|
//$this->sModID definiert den Namen des Moduls, das geloggt werden soll -> tabellenfeld oxmodid
|
|
// Beide Objektwerte sollten immer nach der Objekterstellung nach 'oxNew' gesetzt werden
|
|
|
|
if ($this->getErrorMode($iLogType)) {
|
|
$this->setId();
|
|
$aContent = [
|
|
'oxshopid' => Registry::getConfig()->getShopId(),
|
|
'oxsessid' => $sSessID,
|
|
'oxlogtype' => strtolower($this->getErrorModeName($iLogType)),
|
|
'oxtime' => (new DateTimeImmutable())->format('Y-m-d H:i:s'),
|
|
'oxmodid' => $sModID,
|
|
'oxprofileid' => $this->d3getProfileId() ?: 'none',
|
|
'oxclass' => $sClass,
|
|
'oxfnc' => $sFnc,
|
|
'oxline' => $iLine,
|
|
'oxaction' => $sAction,
|
|
'oxtext' => $mText,
|
|
];
|
|
|
|
$this->assign($aContent);
|
|
$this->insert();
|
|
$this->_handleMailMessage();
|
|
D3ModCfgRegistry::getInstance()->add($this);
|
|
}
|
|
} catch (DBALException|DatabaseConnectionException|DatabaseErrorException|d3ShopCompatibilityAdapterException|d3_cfg_mod_exception $e) {
|
|
Registry::getLogger()->error($e->getMessage(), [$e]);
|
|
}
|
|
|
|
try {
|
|
$this->_handleDie($mText, $blDie);
|
|
} catch (StandardException $e) {
|
|
Registry::getLogger()->error($e->getMessage(), [$e]);
|
|
}
|
|
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function emergency($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::EMERGENCY, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function alert($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::ALERT, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function critical($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::CRITICAL, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function error($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::ERROR, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function warning($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::WARNING, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function notice($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::NOTICE, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
*
|
|
* @return d3log
|
|
*/
|
|
public function info($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::INFO, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function debug($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::DEBUG, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param string $sClass
|
|
* @param string $sFnc
|
|
* @param int $iLine
|
|
* @param null $sAction
|
|
* @param null $mText
|
|
* @param bool $blDie
|
|
* @return d3log
|
|
*/
|
|
public function test($sClass = self::class, $sFnc = __FUNCTION__, $iLine = __LINE__, $sAction = null, $mText = null, $blDie = false)
|
|
{
|
|
return $this->log(d3LogLevel::TEST, $sClass, $sFnc, $iLine, $sAction, $mText, $blDie);
|
|
}
|
|
|
|
/**
|
|
* @param int $iLogType
|
|
*
|
|
* @return int
|
|
*/
|
|
public function getLogBit($iLogType)
|
|
{
|
|
return oxNew(d3bitmask::class)->getIntByBitPosition($iLogType);
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getErrorModes()
|
|
{
|
|
// $iError = $this->getLogType();
|
|
|
|
$aLogTypeStatus = [];
|
|
foreach ($this->aLogTypes as $sLogType => $iLogType) {
|
|
$aLogTypeStatus[$sLogType] = $this->getErrorMode($iLogType);
|
|
}
|
|
|
|
return $aLogTypeStatus;
|
|
}
|
|
|
|
/**
|
|
* @param int $iErrorMode
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function getErrorMode($iErrorMode)
|
|
{
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
startProfile(__METHOD__);
|
|
}
|
|
|
|
$iError = $this->getLogType();
|
|
$iLogBit = $this->getLogBit($iErrorMode);
|
|
$blReturn = oxNew(d3bitmask::class)->isBitSet($iError, $iLogBit);
|
|
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
|
|
return $blReturn;
|
|
}
|
|
|
|
/**
|
|
* @param $sStatus
|
|
* @param $oSet
|
|
* @return bool
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
public function getLogStatus($sStatus, $oSet = false)
|
|
{
|
|
unset($oSet);
|
|
|
|
if (is_int($sStatus)) {
|
|
$flipped = array_flip($this->aLogTypes);
|
|
$sStatus = $flipped[$sStatus];
|
|
}
|
|
|
|
if ($this->getLogSet()->getValue('blLog_useExtendedLogging')) {
|
|
return $this->_getLogStatusExtended($sStatus);
|
|
} else {
|
|
if (strtoupper($sStatus) == 'DEBUG' ||
|
|
strtoupper($sStatus) == 'TEST'
|
|
) {
|
|
return $this->_getLogStatusExtended($sStatus);
|
|
}
|
|
|
|
$aLogLevelArray = $this->_convertLogLevelToModeArray($sStatus);
|
|
$aLogLevelKeys = array_keys($aLogLevelArray);
|
|
|
|
foreach ($this->getAllLogTypes() as $sErrorName => $iLogType) {
|
|
if (in_array($sErrorName, $aLogLevelKeys) && false == $this->getErrorMode($iLogType)) {
|
|
return false;
|
|
} elseif (false == in_array($sErrorName, $aLogLevelKeys) && $this->getErrorMode($iLogType)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param string $sStatus
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function _getLogStatusExtended($sStatus)
|
|
{
|
|
$iErrorMode = $this->getErrorModeId($sStatus);
|
|
|
|
return $this->getErrorMode($iErrorMode);
|
|
}
|
|
|
|
/**
|
|
* @param int $iErrorMode
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getErrorModeName($iErrorMode)
|
|
{
|
|
$aModTypeList = array_keys($this->aLogTypes);
|
|
|
|
return $aModTypeList[$iErrorMode];
|
|
}
|
|
|
|
/**
|
|
* @param string $sErrorName
|
|
*
|
|
* @return int
|
|
*/
|
|
public function getErrorModeId($sErrorName)
|
|
{
|
|
$aModTypeList = array_keys($this->aLogTypes);
|
|
$iErrorMode = array_search(strtoupper($sErrorName), $aModTypeList);
|
|
|
|
return $iErrorMode;
|
|
}
|
|
|
|
/**
|
|
* @param array $aErrorModes
|
|
*
|
|
* @return int
|
|
*/
|
|
public function getLogTypeByArray($aErrorModes = [])
|
|
{
|
|
$aErrorModes = $this->_resolveArrayByLogTypes($aErrorModes);
|
|
|
|
return oxNew(d3bitmask::class)->getIntByBitMask($aErrorModes);
|
|
}
|
|
|
|
/**
|
|
* @param array $aErrorModes
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function _resolveArrayByLogTypes($aErrorModes)
|
|
{
|
|
$aNewTypeArray = [];
|
|
$aErrorModes = array_change_key_case($aErrorModes, CASE_UPPER);
|
|
|
|
foreach (array_keys($this->aLogTypes) as $sTypeName) {
|
|
if (isset($aErrorModes[strtoupper($sTypeName)])) {
|
|
$aNewTypeArray[$sTypeName] = $aErrorModes[strtoupper($sTypeName)];
|
|
} else {
|
|
$aNewTypeArray[$sTypeName] = false;
|
|
}
|
|
}
|
|
|
|
return $aNewTypeArray;
|
|
}
|
|
|
|
/**
|
|
* @param int $iType
|
|
*
|
|
* @return int
|
|
*/
|
|
public function addLogType($iType)
|
|
{
|
|
$this->setLogType(oxNew(d3bitmask::class)->addBit($this->getLogType(), $this->getLogBit($iType)));
|
|
|
|
return $this->getLogType();
|
|
}
|
|
|
|
/**
|
|
* @param int $iType
|
|
*
|
|
* @return int
|
|
*/
|
|
public function removeLogType($iType)
|
|
{
|
|
$this->setLogType(oxNew(d3bitmask::class)->removeBit($this->getLogType(), $this->getLogBit($iType)));
|
|
|
|
return $this->getLogType();
|
|
}
|
|
|
|
/**
|
|
* @return int|false
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
public function convertAdminLogSettings()
|
|
{
|
|
$aLog = [];
|
|
if ($this->getLogSet()->getValue('blLog_useExtendedLogging') &&
|
|
Registry::get(Request::class)->getRequestEscapedParameter('logtypes') &&
|
|
is_array(Registry::get(Request::class)->getRequestEscapedParameter('logtypes'))
|
|
) {
|
|
foreach (Registry::get(Request::class)->getRequestEscapedParameter('logtypes') as $iType => $blStatus) {
|
|
$aLog[$this->getErrorModeName($iType)] = (bool)$blStatus;
|
|
}
|
|
} elseif (Registry::get(Request::class)->getRequestEscapedParameter('loglevel') !== null) {
|
|
$aLog = $this->_convertLogLevelToModeArray(Registry::get(Request::class)->getRequestEscapedParameter('loglevel'));
|
|
|
|
$aLogTypes = Registry::get(Request::class)->getRequestEscapedParameter('logtypes');
|
|
|
|
/** set DEBUG mode */
|
|
if ($aLogTypes && is_array($aLogTypes) && isset($aLogTypes['7'])) {
|
|
$aLog['DEBUG'] = $aLogTypes['7'] ? true : false;
|
|
}
|
|
|
|
/** set TEST mode */
|
|
if ($aLogTypes && is_array($aLogTypes) && isset($aLogTypes['8'])) {
|
|
$aLog['TEST'] = $aLogTypes['8'] ? true : false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
if (count($aLog)) {
|
|
return $this->getLogTypeByArray($aLog);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @param string $sLogLevel
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function _convertLogLevelToModeArray($sLogLevel)
|
|
{
|
|
if (!$sLogLevel) {
|
|
return [];
|
|
}
|
|
|
|
$aLog = $this->aLogGroups[strtolower($sLogLevel)];
|
|
|
|
if (!is_array($aLog)) {
|
|
$aLog = [];
|
|
}
|
|
|
|
return $aLog;
|
|
}
|
|
|
|
/**
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
* @throws StandardException
|
|
* @throws d3ShopCompatibilityAdapterException
|
|
* @throws d3_cfg_mod_exception
|
|
*/
|
|
public function setBacktraceLog()
|
|
{
|
|
$this->Log();
|
|
debug_print_backtrace();
|
|
}
|
|
|
|
/**
|
|
* @param bool $forceCoreTable
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getSqlActiveSnippet($forceCoreTable = false)
|
|
{
|
|
unset($forceCoreTable);
|
|
return "1";
|
|
}
|
|
|
|
/**
|
|
* check, if mailsend has to be intitiated
|
|
* @return bool
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
protected function _checkMailMessage()
|
|
{
|
|
if ($this->_checkMailMessageSlot(1) || $this->_checkMailMessageSlot(2)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param $iSlot
|
|
* @return bool
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
protected function _checkMailMessageSlot($iSlot)
|
|
{
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
startProfile(__METHOD__);
|
|
}
|
|
|
|
$sAdrFieldName = 'sLog_messageadr'.$iSlot;
|
|
$sErrLevelFieldName = 'sLog_messageerrlevel'.$iSlot;
|
|
$sTimeStampFieldName = 'sLog_messagetimestamp'.$iSlot;
|
|
|
|
if ($this->getLogSet()->getValue($sAdrFieldName) &&
|
|
$this->getLogSet()->getValue($sErrLevelFieldName) &&
|
|
(
|
|
false == $this->getLogSet()->getValue($sTimeStampFieldName) ||
|
|
($this->getLogSet()->getValue($sTimeStampFieldName) < $this->_getLastReqMailTimeStamp($iSlot))
|
|
)
|
|
) {
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
public function getUsedMailMessageSlots()
|
|
{
|
|
$sAdrBaseFieldName = 'sLog_messageadr';
|
|
$aSlots = [];
|
|
|
|
for ($i = 1; $i < 100; $i++) {
|
|
$sAdrFieldName = $sAdrBaseFieldName.$i;
|
|
if (strlen($this->getLogSet()->getValue($sAdrFieldName))) {
|
|
$aSlots[] = $i;
|
|
} else {
|
|
break;
|
|
};
|
|
}
|
|
|
|
return $aSlots;
|
|
}
|
|
|
|
/**
|
|
* get timestamp of last required mailsend time
|
|
* @param $iSlot
|
|
* @return int
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
protected function _getLastReqMailTimeStamp($iSlot)
|
|
{
|
|
$iDiff = match ($this->getLogSet()->getValue('sLog_messageintervaltype' . $iSlot)) {
|
|
'hour' => 60 * 60,
|
|
'day' => 60 * 60 * 24,
|
|
'minute' => 60,
|
|
default => 0,
|
|
};
|
|
|
|
$iDiff *= $this->getLogSet()->getValue('sLog_messageinterval' . $iSlot);
|
|
|
|
return time() - $iDiff;
|
|
}
|
|
|
|
/**
|
|
* send info mail to setted mail adresses
|
|
* @throws ContainerExceptionInterface
|
|
* @throws DBALDriverException
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
* @throws NotFoundExceptionInterface
|
|
* @throws StandardException
|
|
* @throws d3ShopCompatibilityAdapterException
|
|
* @throws d3_cfg_mod_exception
|
|
*/
|
|
protected function _sendMailMessage()
|
|
{
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
startProfile(__METHOD__);
|
|
}
|
|
/** @var Connection $db */
|
|
$db = ContainerFactory::getInstance()->getContainer()->get(ConnectionProviderInterface::class)->get();
|
|
|
|
foreach ($this->getUsedMailMessageSlots() as $iSlotId) {
|
|
if ($this->_checkMailMessageSlot($iSlotId)) {
|
|
$aErrorStatus = $db->prepare($this->_getMailDataSelect($iSlotId))->executeQuery()->fetchAllAssociative();
|
|
|
|
if (count($aErrorStatus)) {
|
|
/** @var Email $oEMail */
|
|
$oEMail = oxNew(Email::class);
|
|
$this->_sendLogInfoMail(
|
|
$oEMail,
|
|
$this->getLogSet()->getValue('sLog_messageadr'.$iSlotId),
|
|
$this->_getMailSubject(),
|
|
$this->_getMailContent($aErrorStatus)
|
|
);
|
|
|
|
$this->getLogSet()->setValue('sLog_messagetimestamp'.$iSlotId, time());
|
|
$this->getLogSet()->save();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((bool) Registry::get(ConfigFile::class)->getVar('iDebug')) {
|
|
stopProfile(__METHOD__);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param Email $oEmail
|
|
* @param $sTo
|
|
* @param $sSubject
|
|
* @param $sBody
|
|
*/
|
|
protected function _sendLogInfoMail($oEmail, $sTo, $sSubject, $sBody)
|
|
{
|
|
/** @var Shop $oShop */
|
|
$oShop = Registry::getConfig()->getActiveShop();
|
|
|
|
if (! ($sFromAddress = Registry::getConfig()->getConfigParam('sLogInfoMailFromAddress'))) {
|
|
$sFromAddress = $oShop->getFieldData('oxorderemail');
|
|
}
|
|
|
|
$oEmail->setFrom($sFromAddress, $oShop->__get('oxshops__oxname')->getRawValue());
|
|
$oEmail->setSmtp($oShop);
|
|
|
|
if (is_array($sTo)) {
|
|
foreach ($sTo as $sAddress) {
|
|
$oEmail->setRecipient($sAddress, "");
|
|
$oEmail->setReplyTo($sAddress, "");
|
|
}
|
|
} else {
|
|
$oEmail->setRecipient($sTo, "");
|
|
$oEmail->setReplyTo($sTo, "");
|
|
}
|
|
|
|
//may be changed later
|
|
$oEmail->isHTML(true);
|
|
|
|
$oEmail->setSubject($sSubject);
|
|
$oEmail->setBody($sBody);
|
|
|
|
$oEmail->send();
|
|
}
|
|
|
|
/**
|
|
* create select to get status overview from database
|
|
*
|
|
* @param int $iSlot mail send configuration slot
|
|
*
|
|
* @return string
|
|
* @throws ContainerExceptionInterface
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
protected function _getMailDataSelect($iSlot)
|
|
{
|
|
/** @var Connection $db */
|
|
$db = ContainerFactory::getInstance()->getContainer()->get(ConnectionProviderInterface::class)->get();
|
|
|
|
$sWhere = $this->getLogSet()->getValue('sLog_messagetimestamp' . $iSlot) ? "oxtime > " . $db->quote(
|
|
(new DateTimeImmutable())
|
|
->setTimestamp($this->getLogSet()->getValue('sLog_messagetimestamp' . $iSlot))
|
|
->format('Y-m-d H:i:s')
|
|
) . " " : '1 ';
|
|
|
|
$aLevelFilter = [];
|
|
switch ($this->getLogSet()->getValue('sLog_messageerrlevel' . $iSlot)) {
|
|
case 'warning':
|
|
$aLevelFilter = ['emergency', 'alert', 'critical', 'error', 'warning'];
|
|
break;
|
|
case 'error':
|
|
$aLevelFilter = ['emergency', 'alert', 'critical', 'error'];
|
|
break;
|
|
case 'critical':
|
|
$aLevelFilter = ['emergency', 'alert', 'critical'];
|
|
break;
|
|
case 'alert':
|
|
$aLevelFilter = ['emergency', 'alert'];
|
|
break;
|
|
case 'emergency':
|
|
$aLevelFilter = ['emergency'];
|
|
break;
|
|
}
|
|
|
|
if (count($aLevelFilter)) {
|
|
$sWhere .= ' AND oxlogtype IN ("' . implode('","', $aLevelFilter) . '") ';
|
|
}
|
|
|
|
$sSelect = "SELECT count(oxlogtype) as counter, oxlogtype, oxmodid, CONCAT(substr(oxtext, 1, ".$this->_iInfoMailLogMessageLength."),'...') as text
|
|
FROM " . $this->getViewName() . "
|
|
WHERE " . $sWhere . " AND oxlogtype IS NOT NULL
|
|
GROUP BY oxmodid, oxlogtype, text
|
|
ORDER BY FIELD(oxlogtype,".$this->getLogTypePriorityList4Query()."), counter DESC";
|
|
|
|
return $sSelect;
|
|
}
|
|
|
|
/**
|
|
* generate subject for owner info mail
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function _getMailSubject()
|
|
{
|
|
/** @var Shop $oShop */
|
|
$oShop = Registry::getConfig()->getActiveShop();
|
|
$iDefaultLang = Registry::getConfig()->getConfigParam('sDefaultLang');
|
|
$oLang = Registry::getLang();
|
|
|
|
$sText = sprintf(
|
|
$oLang->translateString('D3_LOGMAIL_SUBJECT', $iDefaultLang, true),
|
|
$oShop->getFieldData('oxname'),
|
|
$oShop->getFieldData('oxurl')
|
|
);
|
|
|
|
return $sText;
|
|
}
|
|
|
|
/**
|
|
* generate content by database data for owner info mail
|
|
*
|
|
* @param array $aStatus status data
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function _getMailContent($aStatus)
|
|
{
|
|
$iDefaultLang = Registry::getConfig()->getConfigParam('sDefaultLang');
|
|
$oLang = Registry::getLang();
|
|
|
|
$sText = $oLang->translateString('D3_LOGMAIL_HEADLINE', $iDefaultLang, true);
|
|
$sText .= "<br><br>";
|
|
|
|
$sText .= "<table style='border: 1px solid silver;'>";
|
|
foreach ($aStatus as $aUniqueStatus) {
|
|
$aUniqueStatus = array_change_key_case($aUniqueStatus, CASE_UPPER);
|
|
$sText .= "<tr><td>".$aUniqueStatus['COUNTER']."x</td>";
|
|
$sText .= "<td>".$aUniqueStatus['OXLOGTYPE']."</td>";
|
|
$sText .= "<td>".sprintf(
|
|
$oLang->translateString('D3_LOGMAIL_INMODULE', $iDefaultLang, true),
|
|
$aUniqueStatus['OXMODID']
|
|
)."</td>";
|
|
$sText .= "<td>".str_replace([chr(10), chr(13)], '', $aUniqueStatus['TEXT'])."</td></tr>";
|
|
}
|
|
$sText .= "</table>";
|
|
|
|
$sText .= "<br>";
|
|
$sText .= $oLang->translateString('D3_LOGMAIL_DESC', $iDefaultLang, true)."<br><br>";
|
|
$sText .= $oLang->translateString('D3_LOGMAIL_LEGENDE', $iDefaultLang, true);
|
|
$sText .= $oLang->translateString('D3_LOGTYPE_DESC', $iDefaultLang, true);
|
|
|
|
return $sText;
|
|
}
|
|
|
|
/**
|
|
* @param bool $blGetDebug
|
|
* @param bool $blGetTestMode
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getAllLogTypes($blGetDebug = false, $blGetTestMode = false)
|
|
{
|
|
$aTypes = $this->aLogTypes;
|
|
|
|
if (false == $blGetDebug) {
|
|
unset($aTypes['DEBUG']);
|
|
}
|
|
|
|
if (false == $blGetTestMode) {
|
|
unset($aTypes['TEST']);
|
|
}
|
|
|
|
return $aTypes;
|
|
}
|
|
|
|
/**
|
|
* @param string $sModId
|
|
* @return array
|
|
* @throws ContainerExceptionInterface
|
|
* @throws DBALDriverException
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
public function getLogTypeList($sModId = '')
|
|
{
|
|
if (false == $this->aD3TypeList || false == count($this->aD3TypeList)) {
|
|
/** @var QueryBuilder $qb */
|
|
$qb = ContainerFactory::getInstance()->getContainer()->get(QueryBuilderFactoryInterface::class)->create();
|
|
|
|
$qb->select('DISTINCT oxlogtype')
|
|
->from($this->getCoreTableName())
|
|
->orderBy('FIELD(oxlogtype,'.$this->getLogTypePriorityList4Query().')');
|
|
|
|
if ($sModId) {
|
|
$qb->where(
|
|
$qb->expr()->like('oxmodid', $qb->createNamedParameter('%'.$sModId.'%'))
|
|
);
|
|
}
|
|
$aRecords = $qb->execute()->fetchAllAssociative();
|
|
|
|
$this->aD3TypeList = [];
|
|
|
|
if (count($aRecords)) {
|
|
foreach ($aRecords as $aRecord) {
|
|
$aRecord = array_change_key_case($aRecord, CASE_UPPER);
|
|
$this->aD3TypeList[] = $aRecord['OXLOGTYPE'];
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this->aD3TypeList;
|
|
}
|
|
|
|
public function getLogTypePriorityList()
|
|
{
|
|
return array_keys($this->aLogTypes);
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
* @throws ContainerExceptionInterface
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
public function getLogTypePriorityList4Query(): string
|
|
{
|
|
/** @var Connection $db */
|
|
$db = ContainerFactory::getInstance()->getContainer()->get(ConnectionProviderInterface::class)->get();
|
|
return implode(',', array_map([$db, 'quote'], $this->getLogTypePriorityList()));
|
|
}
|
|
|
|
/**
|
|
* @param string $sModId
|
|
* @return array
|
|
* @throws ContainerExceptionInterface
|
|
* @throws DBALDriverException
|
|
* @throws DBALException
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
public function getModIdList($sModId = '')
|
|
{
|
|
if (false == $this->aD3ModIdList || false == count($this->aD3ModIdList)) {
|
|
/** @var QueryBuilder $qb */
|
|
$qb = ContainerFactory::getInstance()->getContainer()->get(QueryBuilderFactoryInterface::class)->create();
|
|
$qb->select('DISTINCT oxmodid')
|
|
->from($this->getCoreTableName())
|
|
->orderBy('oxmodid');
|
|
|
|
if ($sModId) {
|
|
$qb->where($qb->expr()->like('oxmodid', $qb->createNamedParameter('%'.$sModId.'%')));
|
|
}
|
|
|
|
$aRecords = $qb->execute()->fetchAllAssociative();
|
|
|
|
$this->aD3ModIdList = [];
|
|
|
|
if (count($aRecords)) {
|
|
foreach ($aRecords as $aRecord) {
|
|
$aRecord = array_change_key_case($aRecord, CASE_UPPER);
|
|
$this->aD3ModIdList[] = $aRecord['OXMODID'];
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this->aD3ModIdList;
|
|
}
|
|
|
|
/**
|
|
* @param string $sModId
|
|
* @return array
|
|
* @throws ContainerExceptionInterface
|
|
* @throws DBALDriverException
|
|
* @throws DBALException
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
public function getClassList($sModId = '')
|
|
{
|
|
if (false == $this->aD3ClassList || false == count($this->aD3ClassList)) {
|
|
/** @var QueryBuilder $qb */
|
|
$qb = ContainerFactory::getInstance()->getContainer()->get(QueryBuilderFactoryInterface::class)->create();
|
|
$qb->select('DISTINCT oxclass')
|
|
->from($this->getCoreTableName())
|
|
->orderBy('oxclass');
|
|
|
|
if ($sModId) {
|
|
$qb->where($qb->expr()->like('oxmodid', $qb->createNamedParameter('%'.$sModId.'%')));
|
|
}
|
|
|
|
$aRecords = $qb->execute()->fetchAllAssociative();
|
|
$this->aD3ClassList = [];
|
|
|
|
if (count($aRecords)) {
|
|
foreach ($aRecords as $aRecord) {
|
|
$aRecord = array_change_key_case($aRecord, CASE_UPPER);
|
|
$this->aD3ClassList[] = $aRecord['OXCLASS'];
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this->aD3ClassList;
|
|
}
|
|
|
|
/**
|
|
* @param bool $sModId
|
|
* @param bool $sType
|
|
* @param bool $sFromTime
|
|
* @param bool $sToTime
|
|
* @return QueryBuilder
|
|
* @throws ContainerExceptionInterface
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
protected function _getDelSql($sModId = false, $sType = false, $sFromTime = false, $sToTime = false): QueryBuilder
|
|
{
|
|
/** @var QueryBuilder $qb */
|
|
$qb = ContainerFactory::getInstance()->getContainer()->get(QueryBuilderFactoryInterface::class)->create();
|
|
$qb->delete($this->getCoreTableName())
|
|
->where($qb->expr()->eq('oxshopid', $qb->createNamedParameter(Registry::getConfig()->getShopId())));
|
|
|
|
$sModId = $sModId ?: Registry::get(Request::class)->getRequestEscapedParameter('delete_oxmodid');
|
|
if ($sModId) {
|
|
$qb->andWhere($qb->expr()->eq('oxmodid', $qb->createNamedParameter($sModId)));
|
|
}
|
|
|
|
$sType = $sType ?: Registry::get(Request::class)->getRequestEscapedParameter('delete_oxtype');
|
|
if ($sType) {
|
|
$qb->andWhere($qb->expr()->eq('oxlogtype', $qb->createNamedParameter($sType)));
|
|
}
|
|
|
|
$sFromTime = $sFromTime ?: Registry::get(Request::class)->getRequestEscapedParameter('delete_oxfromtime');
|
|
if ($sFromTime) {
|
|
$qb->andWhere($qb->expr()->gt('oxtime', $qb->createNamedParameter($sFromTime)));
|
|
}
|
|
|
|
$sToTime = $sToTime ?: Registry::get(Request::class)->getRequestEscapedParameter('delete_oxtotime');
|
|
if ($sToTime) {
|
|
$qb->andWhere($qb->expr()->lt('oxtime', $qb->createNamedParameter($sToTime)));
|
|
}
|
|
|
|
return $qb;
|
|
}
|
|
|
|
/**
|
|
* @param bool $sModId
|
|
* @param bool $sType
|
|
* @param bool $sFromTime
|
|
* @param bool $sToTime
|
|
* @return int
|
|
* @throws ContainerExceptionInterface
|
|
* @throws DBALException
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
public function delLog($sModId = false, $sType = false, $sFromTime = false, $sToTime = false)
|
|
{
|
|
$sql = $this->_getDelSql($sModId, $sType, $sFromTime, $sToTime);
|
|
|
|
return $sql->execute();
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getSearchableFields()
|
|
{
|
|
$aSkipFields = ['oxid'];
|
|
$aFields = array_diff(array_keys($this->_aFieldNames), $aSkipFields);
|
|
|
|
return $aFields;
|
|
}
|
|
|
|
/**
|
|
* get logging modcfg object
|
|
*
|
|
* @return d3_cfg_mod
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
public function getLogSet()
|
|
{
|
|
return d3_cfg_mod::get($this->_sLogSetId);
|
|
}
|
|
|
|
/**
|
|
* register an error handler
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
public function registerErrorHandler()
|
|
{
|
|
if (class_exists(d3_cfg_mod::class) && d3_cfg_mod::isCallable()) {
|
|
try {
|
|
if ($this->getLogSet()->getId() && $this->getLogSet()->getValue('blLog_enableErrorReporting')) {
|
|
register_shutdown_function([$this, 'd3logShutDown']);
|
|
// E_USER_ERROR will catched twice, no additional handling needed
|
|
set_error_handler([$this, 'd3logError'], E_ALL ^ E_USER_ERROR);
|
|
}
|
|
} catch (Exception $e) {
|
|
unset($e);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* log fatal error shutdowns
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
* @throws StandardException
|
|
* @throws d3ShopCompatibilityAdapterException
|
|
* @throws d3_cfg_mod_exception
|
|
*/
|
|
public function d3logShutDown()
|
|
{
|
|
$aError = error_get_last();
|
|
if (is_array($aError) && isset($aError['message'])) {
|
|
$this->d3logError($aError['type'], $aError['message'], $aError['file'], $aError['line']);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $errno
|
|
* @param $errstr
|
|
* @param $errfile
|
|
* @param $errline
|
|
* @return bool
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
* @throws StandardException
|
|
* @throws d3ShopCompatibilityAdapterException
|
|
* @throws d3_cfg_mod_exception
|
|
*/
|
|
public function d3logError($errno, $errstr, $errfile, $errline)
|
|
{
|
|
$sClass = null;
|
|
$sFunction = null;
|
|
$sLine = null;
|
|
$sContent = null;
|
|
|
|
if (self::_d3extractClassName($errfile) == self::class) {
|
|
$aTrace = debug_backtrace();
|
|
$sClass = $aTrace[1]['class'] ?: self::_d3extractClassName($aTrace[1]['file']);
|
|
$sFunction = $aTrace[1]['function'];
|
|
$sLine = $aTrace[1]['line'];
|
|
|
|
foreach (array_keys($aTrace) as $key) {
|
|
if ($aTrace[$key]['object']) {
|
|
unset($aTrace[$key]['object']);
|
|
}
|
|
}
|
|
|
|
$sContent = trim(strip_tags($errstr)) . "\n\n";
|
|
$sContent .= print_r($aTrace, true);
|
|
} else {
|
|
$sClass = self::_d3extractClassName($errfile);
|
|
$sFunction = 'unknown';
|
|
$sLine = $errline;
|
|
$sContent = trim($errstr);
|
|
}
|
|
|
|
$this->Log(
|
|
self::_d3getErrorStatus($errno),
|
|
$sClass,
|
|
$sFunction,
|
|
$sLine,
|
|
'ErrorReporting',
|
|
$sContent . PHP_EOL . print_r($_REQUEST, true)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param $errno
|
|
*
|
|
* @return int
|
|
*/
|
|
private function _d3getErrorStatus($errno)
|
|
{
|
|
$sErrState = null;
|
|
|
|
switch ((int)$errno) {
|
|
case E_NOTICE:
|
|
case E_USER_NOTICE:
|
|
$sErrState = d3LogLevel::NOTICE;
|
|
break;
|
|
case E_WARNING:
|
|
case E_USER_WARNING:
|
|
$sErrState = d3LogLevel::WARNING;
|
|
break;
|
|
case E_ERROR:
|
|
case E_RECOVERABLE_ERROR:
|
|
case E_USER_ERROR:
|
|
$sErrState = d3LogLevel::EMERGENCY;
|
|
break;
|
|
case E_STRICT:
|
|
$sErrState = d3LogLevel::WARNING;
|
|
break;
|
|
case null:
|
|
$sErrState = d3LogLevel::NONE;
|
|
break;
|
|
default:
|
|
$sErrState = d3LogLevel::ERROR;
|
|
}
|
|
|
|
if (version_compare(PHP_VERSION, '5.3', '>')) {
|
|
switch ((int)$errno) {
|
|
case E_DEPRECATED:
|
|
case E_USER_DEPRECATED:
|
|
$sErrState = d3LogLevel::WARNING;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $sErrState;
|
|
}
|
|
|
|
/**
|
|
* @param $sFile
|
|
*
|
|
* @return string
|
|
*/
|
|
private function _d3extractClassName($sFile)
|
|
{
|
|
$sFile = basename($sFile);
|
|
$iEnd = strrpos($sFile, '.');
|
|
|
|
return substr($sFile, 0, $iEnd);
|
|
}
|
|
|
|
/**
|
|
* show profiling
|
|
*/
|
|
public function d3GetProfiling()
|
|
{
|
|
$view = Registry::getConfig()->getActiveView();
|
|
/** @var d3_oxshopcontrol_modcfg_extension $oShopControl */
|
|
$oShopControl = oxNew(ShopControl::class);
|
|
$oShopControl->d3StopMonitoring($view);
|
|
}
|
|
|
|
/**
|
|
* check, if modcfg can get items
|
|
*
|
|
* @return bool
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
*/
|
|
public static function isCallable()
|
|
{
|
|
if (class_exists(d3database::class) &&
|
|
($oD3DataBase = d3database::getInstance()) &&
|
|
$oD3DataBase->checkTableExist(self::$_sD3CoreTable)
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param $sLogType
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getLogTypeTranslation($sLogType)
|
|
{
|
|
$sTranslationIdent = "D3_LOGTYPE_" . strtoupper($sLogType);
|
|
|
|
$sTranslation = Registry::getLang()->translateString($sTranslationIdent);
|
|
|
|
if ($sTranslation == $sTranslationIdent) {
|
|
return $sLogType;
|
|
} else {
|
|
return $sTranslation;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param string $sBaseModId
|
|
* @return string
|
|
* @throws DatabaseConnectionException
|
|
*/
|
|
public function d3BuildExportQuery($sBaseModId = '')
|
|
{
|
|
$aWhere = [];
|
|
|
|
$sModId = Registry::get(Request::class)->getRequestEscapedParameter('export_oxmodid');
|
|
if ($sModId) {
|
|
$aWhere['oxmodid'] = $sModId;
|
|
Registry::getConfig()->getActiveView()->addTplParam('oxmodid', $sModId);
|
|
}
|
|
|
|
$sTime = Registry::get(Request::class)->getRequestEscapedParameter('export_oxtime');
|
|
if ($sTime) {
|
|
$aWhere['oxtime'] = (new DateTimeImmutable($sTime))->format('Y-m-d H:i:s');
|
|
Registry::getConfig()->getActiveView()->addTplParam('oxtime', $sTime);
|
|
}
|
|
|
|
$sSessid = trim(Registry::get(Request::class)->getRequestEscapedParameter('export_oxsessid'));
|
|
if ($sSessid) {
|
|
$aWhere['oxsessid'] = $sSessid;
|
|
Registry::getConfig()->getActiveView()->addTplParam('oxsessid', $sSessid);
|
|
}
|
|
|
|
$sClass = trim(Registry::get(Request::class)->getRequestEscapedParameter('export_oxclass'));
|
|
if ($sClass) {
|
|
$aWhere['oxclass'] = $sClass;
|
|
Registry::getConfig()->getActiveView()->addTplParam('oxclass', $sClass);
|
|
}
|
|
|
|
$sSelect = $this->buildSelectString($aWhere);
|
|
|
|
/** @var Connection $db */
|
|
$db = ContainerFactory::getInstance()->getContainer()->get(ConnectionProviderInterface::class)->get();
|
|
|
|
$aSearch = ['oxtime ='];
|
|
$aReplace = ['oxtime >'];
|
|
if ($sBaseModId) {
|
|
$aSearch[] = ' where 1 ';
|
|
$aReplace[] = ' where 1 AND oxmodid LIKE '.$db->quote('%'.$sBaseModId.'%');
|
|
}
|
|
|
|
$sSelect = str_replace($aSearch, $aReplace, $sSelect);
|
|
|
|
return $sSelect;
|
|
}
|
|
|
|
/**
|
|
* @throws DBALException
|
|
* @throws DatabaseConnectionException
|
|
* @throws DatabaseErrorException
|
|
* @throws StandardException
|
|
* @throws d3ShopCompatibilityAdapterException
|
|
* @throws d3_cfg_mod_exception
|
|
*/
|
|
protected function _handleMailMessage()
|
|
{
|
|
if (false == $this->_blStandAloneUse) {
|
|
if ($this->_checkMailMessage()) {
|
|
$this->_sendMailMessage();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $mText
|
|
* @param $blDie
|
|
*/
|
|
protected function _handleDie($mText, $blDie)
|
|
{
|
|
if ($blDie) {
|
|
die($mText);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param string $sModId
|
|
*
|
|
* @return string
|
|
* @throws DatabaseConnectionException
|
|
* @throws ContainerExceptionInterface
|
|
* @throws NotFoundExceptionInterface
|
|
*/
|
|
public function getItemCount($sModId = '')
|
|
{
|
|
$oQB = ContainerFactory::getInstance()->getContainer()->get(QueryBuilderFactoryInterface::class)->create();
|
|
$oQB->select('count(*)')
|
|
->from($this->getCoreTableName())
|
|
->setMaxResults(1)
|
|
;
|
|
|
|
if ($sModId) {
|
|
$oQB->where('oxmodid LIKE '.$oQB->createNamedParameter('%' . $sModId . '%'));
|
|
}
|
|
|
|
return $oQB->execute()->fetchOne();
|
|
}
|
|
}
|