/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/legacy-base
/buxus
/includes
/classes
/db
/buxus_db_adapter_mysql.php
-
- require_once 'includes/classes/db/buxus_db_adapter.php';
- require_once 'includes/classes/db/buxus_db_statement_pdo.php';
-
- class BuxusDB_Adapter_Mysql extends Zend_Db_Adapter_Pdo_Mysql implements BuxusDB_Adapter {
- /**
- * Default class name for a DB statement.
- *
- * @var string
- */
- protected $_defaultStmtClass = 'BuxusDB_Statement_PDO';
-
- protected function _connect() {
- if ($this->_connection) {
- return;
- }
-
- parent::_connect();
- if (array_key_exists("encoding", $this->_config)) {
- $this->_connection->query("SET CHARACTER SET '" . $this->_config['encoding'] . "'");
- $this->_connection->query("SET NAMES '" . $this->_config['encoding'] . "'");
- }
-
- // $this->_connection->query("SET SESSION sql_mode = 'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'");
- }
-
- public static function affectedRows($result)
- {
- return($result->rowCount());
- }
-
- public function quoteString($str)
- {
- if(empty($str)) {
- return('NULL');
- }
- else {
- return($this->quote($str));
- }
- }
Arguments
"SQLSTATE[HY000]: General error: 2006 MySQL server has gone away"
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/legacy-base
/buxus
/includes
/classes
/db
/buxus_db_adapter_mysql.php
require_once 'includes/classes/db/buxus_db_adapter.php';
require_once 'includes/classes/db/buxus_db_statement_pdo.php';
class BuxusDB_Adapter_Mysql extends Zend_Db_Adapter_Pdo_Mysql implements BuxusDB_Adapter {
/**
* Default class name for a DB statement.
*
* @var string
*/
protected $_defaultStmtClass = 'BuxusDB_Statement_PDO';
protected function _connect() {
if ($this->_connection) {
return;
}
parent::_connect();
if (array_key_exists("encoding", $this->_config)) {
$this->_connection->query("SET CHARACTER SET '" . $this->_config['encoding'] . "'");
$this->_connection->query("SET NAMES '" . $this->_config['encoding'] . "'");
}
// $this->_connection->query("SET SESSION sql_mode = 'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'");
}
public static function affectedRows($result)
{
return($result->rowCount());
}
public function quoteString($str)
{
if(empty($str)) {
return('NULL');
}
else {
return($this->quote($str));
}
}
Arguments
"SET CHARACTER SET 'utf8'"
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/legacy-base
/buxus
/includes
/classes
/db
/buxus_db_adapter_mysql.php
return(addslashes($str));
}
public static function convertStringToNULL($my_string) {
if ($my_string=="") {
return "NULL";
}
return $my_string;
}
public static function convertStringToTrueFalse($my_string, $default = 'F') {
return (in_array($my_string, array('T', 'F')) ? $my_string : $default);
}
use \Illuminate\Database\DetectsLostConnections;
public function reconnect()
{
$this->_connection = null;
$this->_connect();
}
public function disconnect()
{
$this->_connection = null;
}
public function query($sql, $bind = array()) {
try {
if (is_array($bind)) {
foreach ($bind as $key => $value) {
if (is_string($key) && is_array($value)) {
$sql = preg_replace('@' . preg_quote($key) . '@', implode(',', $value), $sql);
unset($bind[$key]);
}
}
}
$result = parent::query($sql, $bind);
} catch (\Exception $e) {
if ($this->causedByLostConnection($e)) {
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/core
/src
/Buxus
/Database
/BuxusMysqlConnector.php
<?php
namespace Buxus\Database;
use Illuminate\Database\Connectors\MySqlConnector;
class BuxusMysqlConnector extends MySqlConnector
{
public function createConnection($dsn, array $config, array $options)
{
$buxus_db = \BuxusDB::get();
$buxus_db->reconnect();
return $buxus_db->getConnection();
}
}
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connectors
/MySqlConnector.php
use PDO;
class MySqlConnector extends Connector implements ConnectorInterface
{
/**
* Establish a database connection.
*
* @param array $config
* @return \PDO
*/
public function connect(array $config)
{
$dsn = $this->getDsn($config);
$options = $this->getOptions($config);
// We need to grab the PDO options that should be used while making the brand
// new connection instance. The PDO options control various aspects of the
// connection's behavior, and some might be specified by the developers.
$connection = $this->createConnection($dsn, $config, $options);
if (! empty($config['database'])) {
$connection->exec("use `{$config['database']}`;");
}
$this->configureEncoding($connection, $config);
// Next, we will check to see if a timezone has been specified in this config
// and if it has we will issue a statement to modify the timezone with the
// database. Setting this DB timezone is an optional configuration item.
$this->configureTimezone($connection, $config);
$this->setModes($connection, $config);
return $connection;
}
/**
* Set the connection character set and collation.
*
Arguments
"mysql:host=localhost;dbname=evuc_live"
array:10 [▶
"driver" => "mysql"
"host" => "localhost"
"database" => "evuc_live"
"username" => "evuclive"
"password" => "oaphaegeeB6rahQu"
"charset" => "utf8"
"collation" => "utf8_unicode_ci"
"prefix" => ""
"strict" => false
"name" => "mysql"
]
array:5 [▶
8 => 0
3 => 2
11 => 0
17 => false
20 => false
]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connectors
/ConnectionFactory.php
{
return array_key_exists('host', $config)
? $this->createPdoResolverWithHosts($config)
: $this->createPdoResolverWithoutHosts($config);
}
/**
* Create a new Closure that resolves to a PDO instance with a specific host or an array of hosts.
*
* @param array $config
* @return \Closure
*/
protected function createPdoResolverWithHosts(array $config)
{
return function () use ($config) {
foreach (Arr::shuffle($hosts = $this->parseHosts($config)) as $key => $host) {
$config['host'] = $host;
try {
return $this->createConnector($config)->connect($config);
} catch (PDOException $e) {
if (count($hosts) - 1 === $key && $this->container->bound(ExceptionHandler::class)) {
$this->container->make(ExceptionHandler::class)->report($e);
}
}
}
throw $e;
};
}
/**
* Parse the hosts configuration item into an array.
*
* @param array $config
* @return array
*/
protected function parseHosts(array $config)
{
$hosts = array_wrap($config['host']);
Arguments
array:10 [▶
"driver" => "mysql"
"host" => "localhost"
"database" => "evuc_live"
"username" => "evuclive"
"password" => "oaphaegeeB6rahQu"
"charset" => "utf8"
"collation" => "utf8_unicode_ci"
"prefix" => ""
"strict" => false
"name" => "mysql"
]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
if (is_null($this->doctrineConnection)) {
$data = ['pdo' => $this->getPdo(), 'dbname' => $this->getConfig('database')];
$this->doctrineConnection = new DoctrineConnection(
$data, $this->getDoctrineDriver()
);
}
return $this->doctrineConnection;
}
/**
* Get the current PDO connection.
*
* @return \PDO
*/
public function getPdo()
{
if ($this->pdo instanceof Closure) {
return $this->pdo = call_user_func($this->pdo);
}
return $this->pdo;
}
/**
* Get the current PDO connection used for reading.
*
* @return \PDO
*/
public function getReadPdo()
{
if ($this->transactions >= 1) {
return $this->getPdo();
}
if ($this->readPdo instanceof Closure) {
return $this->readPdo = call_user_func($this->readPdo);
}
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
if (is_null($this->doctrineConnection)) {
$data = ['pdo' => $this->getPdo(), 'dbname' => $this->getConfig('database')];
$this->doctrineConnection = new DoctrineConnection(
$data, $this->getDoctrineDriver()
);
}
return $this->doctrineConnection;
}
/**
* Get the current PDO connection.
*
* @return \PDO
*/
public function getPdo()
{
if ($this->pdo instanceof Closure) {
return $this->pdo = call_user_func($this->pdo);
}
return $this->pdo;
}
/**
* Get the current PDO connection used for reading.
*
* @return \PDO
*/
public function getReadPdo()
{
if ($this->transactions >= 1) {
return $this->getPdo();
}
if ($this->readPdo instanceof Closure) {
return $this->readPdo = call_user_func($this->readPdo);
}
Arguments
Closure {#286 ▶
class: "Illuminate\Database\Connectors\ConnectionFactory"
this: ConnectionFactory {#233 …}
use: {▶
$config: array:10 [▶
"driver" => "mysql"
"host" => "localhost"
"database" => "evuc_live"
"username" => "evuclive"
"password" => "oaphaegeeB6rahQu"
"charset" => "utf8"
"collation" => "utf8_unicode_ci"
"prefix" => ""
"strict" => false
"name" => "mysql"
]
}
}
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
return $this->pdo;
}
/**
* Get the current PDO connection used for reading.
*
* @return \PDO
*/
public function getReadPdo()
{
if ($this->transactions >= 1) {
return $this->getPdo();
}
if ($this->readPdo instanceof Closure) {
return $this->readPdo = call_user_func($this->readPdo);
}
return $this->readPdo ?: $this->getPdo();
}
/**
* Set the PDO connection.
*
* @param \PDO|\Closure|null $pdo
* @return $this
*/
public function setPdo($pdo)
{
$this->transactions = 0;
$this->pdo = $pdo;
return $this;
}
/**
* Set the PDO connection used for reading.
*
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
protected function prepared(PDOStatement $statement)
{
$statement->setFetchMode($this->fetchMode);
$this->event(new Events\StatementPrepared(
$this, $statement
));
return $statement;
}
/**
* Get the PDO connection to use for a select query.
*
* @param bool $useReadPdo
* @return \PDO
*/
protected function getPdoForSelect($useReadPdo = true)
{
return $useReadPdo ? $this->getReadPdo() : $this->getPdo();
}
/**
* Run an insert statement against the database.
*
* @param string $query
* @param array $bindings
* @return bool
*/
public function insert($query, $bindings = [])
{
return $this->statement($query, $bindings);
}
/**
* Run an update statement against the database.
*
* @param string $query
* @param array $bindings
* @return int
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
/**
* Run a select statement against the database.
*
* @param string $query
* @param array $bindings
* @param bool $useReadPdo
* @return array
*/
public function select($query, $bindings = [], $useReadPdo = true)
{
return $this->run($query, $bindings, function ($query, $bindings) use ($useReadPdo) {
if ($this->pretending()) {
return [];
}
// For select statements, we'll simply execute the query and return an array
// of the database result set. Each element in the array will be a single
// row from the database table, and will either be an array or objects.
$statement = $this->prepared($this->getPdoForSelect($useReadPdo)
->prepare($query));
$this->bindValues($statement, $this->prepareBindings($bindings));
$statement->execute();
return $statement->fetchAll();
});
}
/**
* Run a select statement against the database and returns a generator.
*
* @param string $query
* @param array $bindings
* @param bool $useReadPdo
* @return \Generator
*/
public function cursor($query, $bindings = [], $useReadPdo = true)
{
Arguments
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
return $result;
}
/**
* Run a SQL statement.
*
* @param string $query
* @param array $bindings
* @param \Closure $callback
* @return mixed
*
* @throws \Illuminate\Database\QueryException
*/
protected function runQueryCallback($query, $bindings, Closure $callback)
{
// To execute the statement, we'll simply call the callback, which will actually
// run the SQL against the PDO connection. Then we can calculate the time it
// took to execute and log the query SQL, bindings and time in our memory.
try {
$result = $callback($query, $bindings);
}
// If an exception occurs when attempting to run a query, we'll format the error
// message to include the bindings with SQL, which will make this exception a
// lot more helpful to the developer instead of just the database's errors.
catch (Exception $e) {
throw new QueryException(
$query, $this->prepareBindings($bindings), $e
);
}
return $result;
}
/**
* Log a query in the connection's query log.
*
* @param string $query
* @param array $bindings
* @param float|null $time
Arguments
"SELECT page_type_id FROM tblPageTypes ORDER BY page_type_name ASC"
[]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
* Run a SQL statement and log its execution context.
*
* @param string $query
* @param array $bindings
* @param \Closure $callback
* @return mixed
*
* @throws \Illuminate\Database\QueryException
*/
protected function run($query, $bindings, Closure $callback)
{
$this->reconnectIfMissingConnection();
$start = microtime(true);
// Here we will run this query. If an exception occurs we'll determine if it was
// caused by a connection that has been lost. If that is the cause, we'll try
// to re-establish connection and re-run the query with a fresh connection.
try {
$result = $this->runQueryCallback($query, $bindings, $callback);
} catch (QueryException $e) {
$result = $this->handleQueryException(
$e, $query, $bindings, $callback
);
}
// Once we have run the query we will calculate the time that it took to run and
// then log the query, bindings, and execution time so we will report them on
// the event that the developer needs them. We'll log time in milliseconds.
$this->logQuery(
$query, $bindings, $this->getElapsedTime($start)
);
return $result;
}
/**
* Run a SQL statement.
*
* @param string $query
Arguments
"SELECT page_type_id FROM tblPageTypes ORDER BY page_type_name ASC"
[]
Closure {#292 ▶
class: "Illuminate\Database\Connection"
this: MySqlConnection {#288 …}
parameters: {▶
$query: {}
$bindings: {}
}
use: {▶
$useReadPdo: true
}
}
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/Connection.php
*/
public function select($query, $bindings = [], $useReadPdo = true)
{
return $this->run($query, $bindings, function ($query, $bindings) use ($useReadPdo) {
if ($this->pretending()) {
return [];
}
// For select statements, we'll simply execute the query and return an array
// of the database result set. Each element in the array will be a single
// row from the database table, and will either be an array or objects.
$statement = $this->prepared($this->getPdoForSelect($useReadPdo)
->prepare($query));
$this->bindValues($statement, $this->prepareBindings($bindings));
$statement->execute();
return $statement->fetchAll();
});
}
/**
* Run a select statement against the database and returns a generator.
*
* @param string $query
* @param array $bindings
* @param bool $useReadPdo
* @return \Generator
*/
public function cursor($query, $bindings = [], $useReadPdo = true)
{
$statement = $this->run($query, $bindings, function ($query, $bindings) use ($useReadPdo) {
if ($this->pretending()) {
return [];
}
// First we will create a statement for the query. Then, we will set the fetch
// mode and prepare the bindings for the query. Once that's done we will be
// ready to execute the query against the database and return the cursor.
Arguments
"SELECT page_type_id FROM tblPageTypes ORDER BY page_type_name ASC"
[]
Closure {#292 ▶
class: "Illuminate\Database\Connection"
this: MySqlConnection {#288 …}
parameters: {▶
$query: {}
$bindings: {}
}
use: {▶
$useReadPdo: true
}
}
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/database
/DatabaseManager.php
/**
* Return all of the created connections.
*
* @return array
*/
public function getConnections()
{
return $this->connections;
}
/**
* Dynamically pass methods to the default connection.
*
* @param string $method
* @param array $parameters
* @return mixed
*/
public function __call($method, $parameters)
{
return $this->connection()->$method(...$parameters);
}
}
Arguments
"SELECT page_type_id FROM tblPageTypes ORDER BY page_type_name ASC"
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/support
/Facades
/Facade.php
}
/**
* Handle dynamic, static calls to the object.
*
* @param string $method
* @param array $args
* @return mixed
*
* @throws \RuntimeException
*/
public static function __callStatic($method, $args)
{
$instance = static::getFacadeRoot();
if (! $instance) {
throw new RuntimeException('A facade root has not been set.');
}
return $instance->$method(...$args);
}
}
Arguments
"select"
array:1 [▶
0 => "SELECT page_type_id FROM tblPageTypes ORDER BY page_type_name ASC"
]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/pages
/src
/Buxus
/PageType
/Backend
/PageTypeDatabaseBackend.php
{
\DB::table('tblAccessRightPageTypeUser')
->where('page_type_id', $page_type->getId())
->delete();
foreach ($page_type->getUsersAllowedToInsert() as $user) {
\DB::table('tblAccessRightPageTypeUser')->insert(array(
'user_id' => $user->getId(),
'page_type_id' => $page_type->getId(),
'insert_page_type_right' => 'T',
));
}
}
/**
* @return PageTypeInterface[]
*/
public function getAllPageTypes()
{
$data = collect(\DB::select("SELECT page_type_id FROM tblPageTypes ORDER BY page_type_name ASC"));
$result = array();
foreach ($data as $row) {
$result[] = PageTypesManager::getInstance()->getPageTypeById($row->page_type_id);
}
return $result;
}
/**
* @return PageTypeInterface[]
*/
public function getSuperiorPageTypes(PageTypeInterface $pageType)
{
$tmp = collect(\DB::select("SELECT
PT.page_type_id
FROM
tblPageTypesHierarchy AS PTH
INNER JOIN
tblPageTypes AS PT
ON
PT.page_type_id = PTH.parent_page_type_id
Arguments
"select"
array:1 [▶
0 => "SELECT page_type_id FROM tblPageTypes ORDER BY page_type_name ASC"
]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/pages
/src
/Buxus
/PageType
/Backend
/PageTypeMemcacheCachingBackend.php
return $this->backend->loadPageType($page_type_id);
}
$page_type = $this->storage->get('page-type-' . $page_type_id);
if (!$page_type instanceof PageTypeInterface) {
$page_type = $this->backend->loadPageType($page_type_id);
// cache also checksum
$page_type->getChecksum();
$this->storage->forever('page-type-' . $page_type_id, $page_type);
}
return $page_type;
}
/**
* @return PageTypeInterface[]
*/
public function getAllPageTypes()
{
return $this->backend->getAllPageTypes();
}
/**
* @param PageTypeInterface $pageType
* @return PageTypeInterface[]
*/
public function getSuperiorPageTypes(PageTypeInterface $pageType)
{
return $this->backend->getSuperiorPageTypes($pageType);
}
protected function invalidate(PageTypeInterface $page_type = null)
{
if ($page_type instanceof PageTypeInterface) {
$this->storage->forget('page-type-' . $page_type->getId());
}
}
public function removePageType(PageTypeInterface $page_type)
{
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/pages
/src
/Buxus
/PageType
/Backend
/PageTypeCachingBackend.php
/**
* @param int $page_type_id
* @return PageTypeInterface
*/
public function loadPageType($page_type_id)
{
if (!array_key_exists($page_type_id, $this->page_types) || !isset($this->page_types[$page_type_id])) {
$this->page_types[$page_type_id] = $this->backend->loadPageType($page_type_id);
}
return $this->page_types[$page_type_id];
}
/**
* @return PageTypeInterface
*/
public function getAllPageTypes()
{
if (is_null($this->page_types_all)) {
$this->page_types_all = $this->backend->getAllPageTypes();
}
return $this->page_types_all;
}
/**
* @param PageTypeInterface $pageType
* @return PageTypeInterface
*/
public function getSuperiorPageTypes(PageTypeInterface $pageType)
{
if (!isset($this->superior_page_types[$pageType->getId()])) {
$this->superior_page_types[$pageType->getId()] = $this->backend->getSuperiorPageTypes($pageType);
}
return $this->superior_page_types[$pageType->getId()];
}
public function removePageType(PageTypeInterface $page_type)
{
$this->backend->removePageType($page_type);
$this->invalidate();
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/pages
/src
/Buxus
/PageType
/PageTypesManager.php
* @param string $tag
* @return PageTypeInterface
*/
public function getPageTypeByTag($tag)
{
$page_types = $this->getAllPageTypes();
foreach ($page_types as $page_type) {
if ($page_type->getTag() == $tag) {
return $page_type;
}
}
throw new NotFoundException('Page type with tag ' . $tag . ' not found');
}
/**
* @return PageTypeInterface[]
*/
public function getAllPageTypes()
{
return $this->getBackend()->getAllPageTypes();
}
/**
* @return PageTypeInterface[]
*/
public function getSuperiorPageTypes(PageTypeInterface $page_type)
{
return $this->getBackend()->getSuperiorPageTypes($page_type);
}
public function validatePageType(PageTypeInterface $page_type)
{
$tag = $page_type->getTag();
if (empty($tag)) {
throw new InvalidArgumentException('No page type tag defined');
}
$name = $page_type->getName();
if (empty($name)) {
throw new InvalidArgumentException('No page type name defined');
}
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/pages
/src
/Buxus
/PageType
/PageTypesManager.php
{
return $this->getBackend()->loadPageType($page_type_id);
}
public function pageTypeExistsByTag($tag)
{
try {
return $this->getPageTypeByTag($tag);
} catch (NotFoundException $e) {
return false;
}
}
/**
* @param string $tag
* @return PageTypeInterface
*/
public function getPageTypeByTag($tag)
{
$page_types = $this->getAllPageTypes();
foreach ($page_types as $page_type) {
if ($page_type->getTag() == $tag) {
return $page_type;
}
}
throw new NotFoundException('Page type with tag ' . $tag . ' not found');
}
/**
* @return PageTypeInterface[]
*/
public function getAllPageTypes()
{
return $this->getBackend()->getAllPageTypes();
}
/**
* @return PageTypeInterface[]
*/
public function getSuperiorPageTypes(PageTypeInterface $page_type)
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/util
/src
/Buxus
/Util
/PageTypeID.php
require_once 'includes/constants.inc.php';
class PageTypeID extends \PageTypesConstantsIDs
{
public static function id($name)
{
return defined('static::' . $name) ? constant('static::' . $name) : false;
}
public static function __callStatic($name, $arguments)
{
if (preg_match('@^(.*)_ID$@', $name, $matches)) {
$tag = mb_strtolower($matches[1]);
try {
/**
* @var PageTypesManager $pageTypeManager
**/
$pageTypeManager = app('buxus:page-types-manager');
$pageType = $pageTypeManager->getPageTypeByTag($tag);
return $pageType->getId();
} catch (\Exception $e) {
}
}
return null;
}
}
Arguments
"layout_element_megamenu"
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus-libs
/mega-menu
/src
/MegaMenuModule.php
$this->publishes([
__DIR__ . '/../migrations/' => database_path('migrations/buxus-libs/mega-menu/'),
], 'migrations');
$this->publishes(array(
__DIR__ . '/../assets/jetmenu.js' => assets_path('/js/jetmenu/jetmenu.js'),
));
$this->app->bindIf('buxus:layouts:mega-menu', MegaMenu::class);
}
public function boot()
{
/**
* @var \Layout\LayoutManager $manager
*/
$manager = app('buxus:layouts:manager');
if (PageTypeID::LAYOUT_ELEMENT_MEGAMENU_ID()) {
$manager->setLayoutType(PageTypeID::LAYOUT_ELEMENT_MEGAMENU_ID(), '\Krabica\MegaMenu\Layout\Items\Megamenu', false);
}
if (PageTypeID::LAYOUT_ELEMENT_HOME_BUTTON_ID()) {
$manager->setLayoutType(PageTypeID::LAYOUT_ELEMENT_HOME_BUTTON_ID(), '\Krabica\MegaMenu\Layout\Items\HomeButton', false);
}
if (PageTypeID::LAYOUT_ELEMENT_MENU_CATEGORIES_ID()) {
$manager->setLayoutType(PageTypeID::LAYOUT_ELEMENT_MENU_CATEGORIES_ID(), '\Krabica\MegaMenu\Layout\Items\MenuCategories', false);
}
if (PageTypeID::LAYOUT_ELEMENT_MENU_LINK_ID()) {
$manager->setLayoutType(PageTypeID::LAYOUT_ELEMENT_MENU_LINK_ID(), '\Krabica\MegaMenu\Layout\Items\MenuLink', false);
}
}
}
Arguments
"LAYOUT_ELEMENT_MEGAMENU_ID"
[]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/container
/BoundMethod.php
class BoundMethod
{
/**
* Call the given Closure / class@method and inject its dependencies.
*
* @param \Illuminate\Container\Container $container
* @param callable|string $callback
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*/
public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
{
if (static::isCallableWithAtSign($callback) || $defaultMethod) {
return static::callClass($container, $callback, $parameters, $defaultMethod);
}
return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
});
}
/**
* Call a string reference to a class using Class@method syntax.
*
* @param \Illuminate\Container\Container $container
* @param string $target
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*
* @throws \InvalidArgumentException
*/
protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
{
$segments = explode('@', $target);
// We will assume an @ sign is used to delimit the class name from the method
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/container
/BoundMethod.php
class BoundMethod
{
/**
* Call the given Closure / class@method and inject its dependencies.
*
* @param \Illuminate\Container\Container $container
* @param callable|string $callback
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*/
public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
{
if (static::isCallableWithAtSign($callback) || $defaultMethod) {
return static::callClass($container, $callback, $parameters, $defaultMethod);
}
return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
});
}
/**
* Call a string reference to a class using Class@method syntax.
*
* @param \Illuminate\Container\Container $container
* @param string $target
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*
* @throws \InvalidArgumentException
*/
protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
{
$segments = explode('@', $target);
// We will assume an @ sign is used to delimit the class name from the method
Arguments
array:2 [▶
0 => MegaMenuModule {#191}
1 => "boot"
]
[]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/container
/BoundMethod.php
* @param callable $callback
* @param mixed $default
* @return mixed
*/
protected static function callBoundMethod($container, $callback, $default)
{
if (! is_array($callback)) {
return $default instanceof Closure ? $default() : $default;
}
// Here we need to turn the array callable into a Class@method string we can use to
// examine the container and see if there are any method bindings for this given
// method. If there are, we can call this method binding callback immediately.
$method = static::normalizeMethod($callback);
if ($container->hasMethodBinding($method)) {
return $container->callMethodBinding($method, $callback[0]);
}
return $default instanceof Closure ? $default() : $default;
}
/**
* Normalize the given callback into a Class@method string.
*
* @param callable $callback
* @return string
*/
protected static function normalizeMethod($callback)
{
$class = is_string($callback[0]) ? $callback[0] : get_class($callback[0]);
return "{$class}@{$callback[1]}";
}
/**
* Get all dependencies for a given method.
*
* @param \Illuminate\Container\Container
* @param callable|string $callback
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/container
/BoundMethod.php
/**
* Call the given Closure / class@method and inject its dependencies.
*
* @param \Illuminate\Container\Container $container
* @param callable|string $callback
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*/
public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
{
if (static::isCallableWithAtSign($callback) || $defaultMethod) {
return static::callClass($container, $callback, $parameters, $defaultMethod);
}
return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
});
}
/**
* Call a string reference to a class using Class@method syntax.
*
* @param \Illuminate\Container\Container $container
* @param string $target
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*
* @throws \InvalidArgumentException
*/
protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
{
$segments = explode('@', $target);
// We will assume an @ sign is used to delimit the class name from the method
// name. We will split on this @ sign and then build a callable array that
// we can pass right back into the "call" method for dependency binding.
Arguments
Application {#2}
array:2 [▶
0 => MegaMenuModule {#191}
1 => "boot"
]
Closure {#231 ▶
class: "Illuminate\Container\BoundMethod"
use: {▶
$container: Application {#2 …}
$callback: array:2 [▶
0 => MegaMenuModule {#191}
1 => "boot"
]
$parameters: []
}
}
/home
/evuc
/live
/releases
/20220124095935
/vendor
/illuminate
/container
/Container.php
* @return \Closure
*/
public function wrap(Closure $callback, array $parameters = [])
{
return function () use ($callback, $parameters) {
return $this->call($callback, $parameters);
};
}
/**
* Call the given Closure / class@method and inject its dependencies.
*
* @param callable|string $callback
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*/
public function call($callback, array $parameters = [], $defaultMethod = null)
{
return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
}
/**
* Get a closure to resolve the given type from the container.
*
* @param string $abstract
* @return \Closure
*/
public function factory($abstract)
{
return function () use ($abstract) {
return $this->make($abstract);
};
}
/**
* Resolve the given type with the given parameter overrides.
*
* @param string $abstract
* @param array $parameters
Arguments
Application {#2}
array:2 [▶
0 => MegaMenuModule {#191}
1 => "boot"
]
[]
null
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/modules
/src
/BuxusModuleManager.php
*/
$module = new $class($app);
if (!is_a($module, '\\' . __NAMESPACE__ . '\\BuxusModule')) {
throw new \InvalidArgumentException('Incompatible module class: ' . $class);
}
if (method_exists($module, 'register')) {
$module->register();
}
$modules[] = $module;
}
BuxusCli::getInstance()->addCommand(VendorPublishCommand::class);
// now boot the module as all the modules have registered their bindings
foreach ($modules as $module) {
if (method_exists($module, 'boot')) {
$app->call([$module, 'boot']);
}
}
}
}
Arguments
array:2 [▶
0 => MegaMenuModule {#191}
1 => "boot"
]
/home
/evuc
/live
/releases
/20220124095935
/vendor
/buxus
/core
/src
/buxus_bootstrap.php
get_include_path() . PATH_SEPARATOR .
BUXUS_LEGACY_RUNTIME_ROOT . PATH_SEPARATOR .
CORE_BUXUS_DIR . '/buxus/' . PATH_SEPARATOR .
LEGACY_BASE_BUXUS_DIR . '/buxus/' . PATH_SEPARATOR .
BASE_BUXUS_DIR . '/buxus/application/models' . PATH_SEPARATOR
);
// setup environment
if (file_exists(BASE_BUXUS_DIR . '/.env')) {
$dotenv = new Dotenv\Dotenv(BASE_BUXUS_DIR);
$dotenv->overload();
}
$buxus_kernel = new \Buxus\Core\Kernel($app);
$buxus_kernel->bootstrap();
// boot BUXUS modules
\Buxus\Module\BuxusModuleManager::addModule(\Buxus\BuxusCoreModule::class);
\Buxus\Module\BuxusModuleManager::addModule(\Buxus\Event\BuxusEventModule::class);
\Buxus\Module\BuxusModuleManager::getInstance()->bootstrap(app());
error_reporting(E_ALL - E_NOTICE - E_STRICT - E_DEPRECATED);
require_once LEGACY_BASE_BUXUS_DIR . '/buxus/includes/config.php';
require_once LEGACY_BASE_BUXUS_DIR . '/buxus/includes/connect.php';
require_once LEGACY_BASE_BUXUS_DIR . '/buxus/includes/global.php';
Arguments
/home
/evuc
/live
/releases
/20220124095935
/public
/buxus.php
<?php
define('BASE_BUXUS_DIR', realpath(__DIR__ . '/../'));
require_once __DIR__ . '/../vendor/autoload.php';
require_once CORE_BUXUS_DIR . '/src/buxus_bootstrap.php';
require_once '../vendor/buxus/legacy-base/buxus/includes/database.php';
$router = app('buxus-router');
$router->dispatch($_SERVER['REQUEST_URI']);
Arguments
"/home/evuc/live/releases/20220124095935/vendor/buxus/core/src/buxus_bootstrap.php"