25:        public function getServerVersion(): string
26:        {
27:            return $this->connection->get_server_info();
28:        }
29:    
30:        public function prepare(string $sql): Statement
31:        {
32:            try {
33:                $stmt = $this->connection->prepare($sql);
34:            } catch (mysqli_sql_exception $e) {
35:                throw ConnectionError::upcast($e);
36:            }
37:    
38:            if ($stmt === false) {
39:                throw ConnectionError::new($this->connection);

 9:    use Doctrine\DBAL\Driver\Statement;
10:    
11:    abstract class AbstractConnectionMiddleware implements Connection
12:    {
13:        public function __construct(private readonly Connection $wrappedConnection)
14:        {
15:        }
16:    
17:        public function prepare(string $sql): Statement
18:        {
19:            return $this->wrappedConnection->prepare($sql);
20:        }
21:    
22:        public function query(string $sql): Result
23:        {

18:            private DebugStack $stack,
19:            private string $connectionName,
20:        )
21:        {
22:            parent::__construct($connection);
23:        }
24:    
25:        public function prepare(string $sql): DebugStatement
26:        {
27:            return new DebugStatement(
28:                parent::prepare($sql),
29:                $this->stack,
30:                $this->connectionName,
31:                $sql
32:            );

13:    {
14:        public function __construct(
15:            private Connection $wrappedConnection,
16:            private TracingSQLLogger $logger
17:        ) {
18:        }
19:    
20:        public function prepare(string $sql): Statement
21:        {
22:            return new TracingStatement(
23:                $this->wrappedConnection->prepare($sql),
24:                $this->logger,
25:                $sql
26:            );
27:        }

788:            if ($qcp !== null) {
789:                return $this->executeCacheQuery($sql, $params, $types, $qcp);
790:            }
791:    
792:            $connection = $this->connect();
793:    
794:            try {
795:                if (count($params) > 0) {
796:                    [$sql, $params, $types] = $this->expandArrayParameters($sql, $params, $types);
797:    
798:                    $stmt = $connection->prepare($sql);
799:    
800:                    $this->bindParameters($stmt, $params, $types);
801:    
802:                    $result = $stmt->execute();

17:        public function __construct(string $sql)
18:        {
19:            $this->sqlStatements = $sql;
20:        }
21:    
22:        /**
23:         * {@inheritDoc}
24:         */
25:        public function execute(Connection $conn, array $params, array $types): Result
26:        {
27:            return $conn->executeQuery($this->getSqlStatements(), $params, $types, $this->queryCacheProfile);
28:        }
29:    }

null

286:    
287:            [$sqlParams, $types] = $this->processParameterMappings($paramMappings);
288:    
289:            $this->evictResultSetCache(
290:                $executor,
291:                $sqlParams,
292:                $types,
293:                $this->em->getConnection()->getParams(),
294:            );
295:    
296:            return $executor->execute($this->em->getConnection(), $sqlParams, $types);
297:        }
298:    
299:        /**
300:         * @param array<string,mixed> $sqlParams

920:    
921:                if (! $result) {
922:                    $result = [];
923:                }
924:    
925:                $setCacheEntry = static function ($data) use ($cache, $result, $cacheItem, $realCacheKey): void {
926:                    $cache->save($cacheItem->set($result + [$realCacheKey => $data]));
927:                };
928:            }
929:    
930:            $stmt = $this->_doExecute();
931:    
932:            if (is_numeric($stmt)) {
933:                $setCacheEntry($stmt);
934:    

876:         * @phpstan-param string|AbstractQuery::HYDRATE_*|null         $hydrationMode
877:         */
878:        public function execute(
879:            ArrayCollection|array|null $parameters = null,
880:            string|int|null $hydrationMode = null,
881:        ): mixed {
882:            if ($this->cacheable && $this->isCacheEnabled()) {
883:                return $this->executeUsingQueryCache($parameters, $hydrationMode);
884:            }
885:    
886:            return $this->executeIgnoreQueryCache($parameters, $hydrationMode);
887:        }
888:    
889:        /**
890:         * Execute query ignoring second level cache.

null

1

678:    
679:        /**
680:         * Gets the list of results for the query.
681:         *
682:         * Alias for execute(null, $hydrationMode = HYDRATE_OBJECT).
683:         *
684:         * @phpstan-param string|AbstractQuery::HYDRATE_* $hydrationMode
685:         */
686:        public function getResult(string|int $hydrationMode = self::HYDRATE_OBJECT): mixed
687:        {
688:            return $this->execute(null, $hydrationMode);
689:        }
690:    
691:        /**
692:         * Gets the array of results for the query.

null

1

224:            }
225:            
226:            // ✅ DISTINCT pro správnou hydrataci ManyToMany
227:            if (!empty($include)) {
228:                $qb->distinct(true);
229:            }
230:    
231:            // Načti pouze entity s identifikátory z první fáze
232:            $this->applyIdentifierFilter($qb, $identifiers, $identifierFields, $fromTableAlias);
233:    
234:            return $qb->getQuery()->getResult();
235:        }
236:    
237:        /**
238:         * Aplikuje filtry na QueryBuilder

72:                $limit
73:            );
74:    
75:            // Pokud nejsou žádné výsledky, vrať prázdné pole
76:            if (empty($identifiers)) {
77:                $totalCount = $computeTotalCount ? $this->computeTotalCount($filters) : 0;
78:                return [[], $totalCount];
79:            }
80:    
81:            // FÁZE 2: Načti kompletní entity s includes
82:            $results = $this->fetchCompleteEntities(
83:                $entityClass,
84:                $fromTableAlias,
85:                $identifiers,
86:                $columns,

'App\UI\Api\Blog\Models\Entities\Article'

'article'

array (0)

 9:        public function findAll(
10:            ?array $filters = [],
11:            ?array $orderBys = null,
12:            ?int $offset = null,
13:            ?int $limit = null,
14:            ?array $columns = null,
15:            bool $computeTotalCount = false,
16:            ?array $includes = []
17:        ): array
18:        {
19:            return $this->repository->getAll($filters, $orderBys, $offset, $limit, $columns, $computeTotalCount, $includes);
20:        }
21:    }

0

5

array (0)

false

143:         */
144:        protected function findAllFromDb(
145:            array $includes = [], 
146:            array $filters = [], 
147:            ?array $orderBy = null, 
148:            ?int $offset = null, 
149:            ?int $limit = null, 
150:            ?array $columns = null, 
151:            bool $computeTotalCount = false
152:        ): array {
153:            return $this->mapper->findAll($filters, $orderBy, $offset, $limit, $columns, $computeTotalCount, $includes);
154:        }
155:    
156:        // ==========================================
157:        // REQUIRED DEPENDENCIES

0

5

array (0)

false

 89:                        $this->debugger->logInfo("Service::findAll() - Partial cache miss, loading from DB");
 90:                    }
 91:                } else {
 92:                    if ($this->debugger !== null) {
 93:                        $this->debugger->logInfo("Service::findAll() - CACHE MISS for query");
 94:                    }
 95:                }
 96:            }
 97:    
 98:            // === 3. LOAD FROM DATABASE ===
 99:            [$entities, $totalCount] = $this->findAllFromDb($includes, $filters, $orderBy, $offset, $limit, $columns, $computeTotalCount);
100:    
101:            // === 4. SAVE TO CACHE ===
102:            if ($this->shouldUseCache($useCache, true) && !empty($entities)) {
103:                // queryKey už obsahuje 'query:' prefix z generateQueryKey()

0

5

array (0)

false

 7:    /**
 8:     * @template T of BaseEntity
 9:     */
10:    trait GetAllTrait
11:    {
12:        /**
13:         * @return T[]
14:         */
15:        public function findAll( ?array $includes = [], ?array $filters = [], ?array $orderBys = null, ?int $offset = null, ?int $limit = null, ?array $columns = null, bool $computeTotalCount = false): array
16:        {
17:            $results = $this->service->findAll($includes, $filters, $orderBys, $offset, $limit, $columns, $computeTotalCount);
18:    
19:            list($items, $totalCount) = $results;
20:            
21:            $this->totalCount = ($computeTotalCount) ? $totalCount : NULL;

0

5

array (0)

false

20:            $computeTotalCount = boolval($requestParams['computeTotalCount']??FALSE);
21:            $include  = $requestParams['include']??[];
22:    
23:            $data = $this->getGetAllData($filters, $orderBys, $offset, $limit, $columns, $computeTotalCount, $include);
24:            $this->sendJson($data);
25:        }
26:    
27:        public function getGetAllData(array $filters = [], ?array $orderBys = NULL, ?int $offset = NULL, ?int $limit = NULL, ?array $columns = NULL, bool $computeTotalCount = FALSE, array $includes = []): array
28:        {
29:            $rebuildedFilters = FilterBuilder::buildFilters($filters);
30:            $itemList = $this->manager->findAll(
31:                $includes, 
32:                $rebuildedFilters, 
33:                $orderBys, 
34:                $offset, 

0

5

array (0)

false

327:                $methodName = 'get' . ucfirst($action) . 'Data';
328:                if (!method_exists($presenter, $methodName)) {
329:                    throw new \RuntimeException("Metoda $methodName neexistuje v presenteru $presenterName");
330:                }
331:    
332:                $reflection = new \ReflectionClass($presenter);
333:                $method = $reflection->getMethod($methodName);
334:                $method->setAccessible(true);
335:    
336:                // Získání a vrácení dat
337:                return $method->invoke($presenter, ...$params);
338:            } catch (\Nette\Application\InvalidPresenterException $e) {
339:                throw new \RuntimeException("Presenter $presenterName nebyl nalezen", 0, $e);
340:            }
341:        }

0

5

array (0)

false

144:         * @throws \RuntimeException Pokud metoda v presenteru neexistuje nebo HTTP chyba
145:         */
146:        public function call(
147:            string $endpoint, 
148:            array $params = [], 
149:            ?string $callType = null, 
150:            string $method = 'GET'
151:        ): mixed {
152:            $finalCallType = $callType ?? $this->callType;
153:            if ($finalCallType === self::INTERNAL_CALL) {
154:                return $this->internalCall($endpoint, $params);
155:            } else {
156:                return $this->externalCall($endpoint, $params, $method);
157:            }
158:        }

'api/blog/article/getAll'

20:    
21:        public function findBy(?array $filters = [], array $include = []): array {
22:            $rows = $this->bridge->call($this->apiEndpoint . '/get-by',  [
23:                'filters' => $filters,
24:                'includes' => $include
25:            ])??[];
26:            return $rows;
27:        }
28:    
29:        public function findAll(?array $filters = [], ?array $orderBys = null, ?int $offset = null, ?int $limit = null, ?array $columns = null, bool $computeTotalCount = false, array $include = []): array {
30:            return  $this->bridge->call($this->apiEndpoint . '/get-all', [
31:                'filters' => $filters,
32:                'orderBys' => $orderBys,
33:                'offset' => $offset,
34:                'limit' => $limit,

'api/blog/article/get-all'

null

'POST'

28:            if (empty($data)) {
29:                return null;
30:            }
31:            
32:            // ✅ Použij hydrateWithReferences() - automaticky načte references
33:            return $this->hydrator->hydrateWithReferences($data, $this->getEntityClass());
34:        }
35:    
36:        public function findAll(?array $filters = [], ?array $orderBys = null, ?int $offset = null, ?int $limit = null, ?array $columns = null, bool $computeTotalCount = false, array $include = []): array 
37:        {
38:            $apiResponse = $this->repository->findAll($filters, $orderBys, $offset, $limit, $columns, $computeTotalCount, $include);
39:            if (empty($apiResponse)) {
40:                return [[], 0];
41:            }
42:            

0

5

array (0)

false

15:    
16:        public function find(int $id, array $include = []): ?BaseEntity {
17:            return $this->mapper->find($id, $include);
18:        }
19:    
20:        public function findBy(array|null $filters = [], array|null $include = []): ?BaseEntity {
21:            return $this->mapper->findBy($filters, $include);
22:        }
23:    
24:        public function findAll(array|null $filters = [], array|null $orderBys = null, int|null $offset = null, int|null $limit = null, array|null $columns = null, bool $computeTotalCount = false, array $include = []): array {
25:            $data = $this->mapper->findAll($filters, $orderBys, $offset, $limit, $columns, $computeTotalCount, $include);
26:            $this->totalCount = ($computeTotalCount) ? $data[1]??NULL : NULL;
27:            return $data;   
28:        }
29:    }

0

5

array (0)

false

76:        // === Vykonání dotazu ===
77:        
78:        /**
79:         * Explicitní vykonání - vrací pole entit
80:         * 
81:         * @return T[]
82:         */
83:        public function execute(): array
84:        {
85:            if ($this->result === null) {
86:                [$items, $totalCount] = $this->service->findAll(
87:                    $this->criteria->filters,
88:                    $this->criteria->orderBy,
89:                    $this->criteria->offset,
90:                    $this->criteria->limit,

0

5

array (0)

false

25:            else if(!empty($showOnlyCategoryIds)) {
26:                $filters['categoryId'] = new InFilter('categoryId', $showOnlyCategoryIds);
27:            }
28:          
29:            $filters['activated'] = new EqualFilter('activated', 1);
30:            $filters['published'] = new DateBeforeOrEqualFilter('published', 'NOW');
31:            $articleList = $this->articleManager->findAll(
32:                $filters, 
33:                $orderBy, 
34:                0, 
35:                $maxNumber)->include(['translations', 'image.translations', 'categories.translations'])->execute();
36:    
37:            
38:            $this->template->articleItems = $articleList;
39:            

23:    
24:        public function render(string $style = 'Style1', array $orderBy = ['id' => false], int $maxNumber = 5, int $numberOnFirstRow = 1, int $numberOnOtherRow = 1, string $headingTag = 'div', array $showOnlyCategoryIds = []) {
25:            $this->template->id = $this->getUniqueId();
26:            $this->template->uniqueId = $this->getUniqueId();
27:            $this->template->style = $style;
28:    
29:            $this->numberOnFirstRow = $numberOnFirstRow;
30:            $this->numberOnOtherRow = $numberOnOtherRow;
31:            $this->headingTag = $headingTag;
32:            
33:            $this->intilializeRender($maxNumber, $orderBy, $showOnlyCategoryIds);
34:            $this->setTemplateFile(__DIR__ . '/Template/', 'Template.latte');
35:            return $this->template->render();
36:        }
37:      

5

array (0)

29:            $this->numberOnFirstRow = $numberOnFirstRow;
30:            $this->numberOnOtherRow = $numberOnOtherRow;
31:            $this->headingTag = $headingTag;
32:            
33:            $this->intilializeRender($maxNumber, $orderBy, $showOnlyCategoryIds);
34:            $this->setTemplateFile(__DIR__ . '/Template/', 'Template.latte');
35:            return $this->template->render();
36:        }
37:      
38:        public function renderStyle1(array $orderBy = ['id' => false], int $maxNumber = 5, int $numberOnFirstRow = 1, int $numberOnOtherRow = 1, string $headingTag = 'div', array $showOnlyCategoryIds = []) {
39:            return $this->render('Style1', $orderBy, $maxNumber, $numberOnFirstRow, $numberOnOtherRow, $headingTag, $showOnlyCategoryIds);
40:        }
41:        public function renderStyle2(array $orderBy = ['id' => false], int $maxNumber = 5, int $numberOnFirstRow = 1, int $numberOnOtherRow = 1, string $headingTag = 'div', array $showOnlyCategoryIds = []) {
42:            return $this->render('Style2', $orderBy, $maxNumber, $numberOnFirstRow, $numberOnOtherRow, $headingTag, $showOnlyCategoryIds);
43:        }

'Style1'

5

2

1

'div'

array (0)

100:                }
101:    
102:            } elseif ($this->parentName) { // extends
103:                $this->params = $params;
104:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
105:    
106:            } elseif ($block !== null) { // single block rendering
107:                $this->renderBlock($block, $this->params);
108:    
109:            } else {
110:                $this->main($params);
111:            }
112:        }
113:    
114:    

null

67:    
68:    
69:        /**
70:         * Renders template to output.
71:         * @param  object|mixed[]  $params
72:         */
73:        public function render(string $name, object|array $params = [], ?string $block = null): void
74:        {
75:            $template = $this->createTemplate($name, $this->processParams($params));
76:            $template->global->coreCaptured = false;
77:            $template->render($block);
78:        }
79:    
80:    
81:        /**

null

37:    
38:        /**
39:         * Renders template to output.
40:         */
41:        public function render(?string $file = null, array $params = []): void
42:        {
43:            Nette\Utils\Arrays::toObject($params, $this);
44:            if (isset($this->blueprint)) {
45:                Nodes\TemplatePrintNode::printClass($this->getParameters(), $this->blueprint);
46:            }
47:            $this->latte->render($file ?: $this->file, $this);
48:        }
49:    
50:    
51:        /**

'/var/www/clients/client1/web1/web/subdom/tmp2/app/UI/Front/Blog/Components/LastArticleListComponent/Template//Template.latte'

15:        public function render(string $style = 'Style1', int $maxNumber = 5, int $numberOnFirstRow = 1, int $numberOnOtherRow = 1, string $headingTag = 'div', array $showOnlyCategoryIds = []) {
16:    
17:            $this->template->style = $style;
18:            $this->template->maxNumber = $maxNumber;
19:            $this->template->numberOnFirstRow = $numberOnFirstRow;
20:            $this->template->numberOnOtherRow = $numberOnOtherRow;
21:            $this->template->headingTag = $headingTag;
22:            $this->template->showOnlyCategoryIds = $showOnlyCategoryIds;
23:            
24:            $this->setTemplateFile(__DIR__ . '/Template/', 'Template.latte');
25:            return $this->template->render();
26:        }
27:    
28:        public function renderStyle1(int $maxNumber = 5, int $numberOnFirstRow = 1, int $numberOnOtherRow = 1, string $headingTag = 'div', array $showOnlyCategoryIds = []) {
29:            return $this->render('Style1', $maxNumber, $numberOnFirstRow, $numberOnOtherRow, $headingTag, $showOnlyCategoryIds);

19:            $this->template->numberOnFirstRow = $numberOnFirstRow;
20:            $this->template->numberOnOtherRow = $numberOnOtherRow;
21:            $this->template->headingTag = $headingTag;
22:            $this->template->showOnlyCategoryIds = $showOnlyCategoryIds;
23:            
24:            $this->setTemplateFile(__DIR__ . '/Template/', 'Template.latte');
25:            return $this->template->render();
26:        }
27:    
28:        public function renderStyle1(int $maxNumber = 5, int $numberOnFirstRow = 1, int $numberOnOtherRow = 1, string $headingTag = 'div', array $showOnlyCategoryIds = []) {
29:            return $this->render('Style1', $maxNumber, $numberOnFirstRow, $numberOnOtherRow, $headingTag, $showOnlyCategoryIds);
30:        }
31:        
32:        public function renderStyle2(int $maxNumber = 5, int $numberOnFirstRow = 1, int $numberOnOtherRow = 1, string $headingTag = 'div', array $showOnlyCategoryIds = []) {
33:            return $this->render('Style2', $maxNumber, $numberOnFirstRow, $numberOnOtherRow, $headingTag, $showOnlyCategoryIds);

'Style1'

5

2

1

'div'

array (0)

115:            // Sestavení názvu render metody
116:            $renderMethodName = 'render' . ucfirst($renderMethod);
117:            
118:            // Kontrola existence render metody
119:            if (!method_exists($instance, $renderMethodName)) {
120:                throw new \RuntimeException("Render method '{$renderMethodName}' not found in component '{$componentName}'");
121:            }
122:            
123:            // Vykreslení komponenty
124:            ob_start();
125:            $instance->$renderMethodName(...$args);
126:            return ob_get_clean();
127:        }
128:        
129:        /**

5

2

1

100:                }
101:    
102:            } elseif ($this->parentName) { // extends
103:                $this->params = $params;
104:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
105:    
106:            } elseif ($block !== null) { // single block rendering
107:                $this->renderBlock($block, $this->params);
108:    
109:            } else {
110:                $this->main($params);
111:            }
112:        }
113:    
114:    

null

162:        }
163:    
164:    
165:        /**
166:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
167:         * @internal
168:         */
169:        public function renderToContentType(string|\Closure|null $mod, ?string $block = null): void
170:        {
171:            $this->filter(
172:                fn() => $this->render($block),
173:                $mod,
174:                static::ContentType,
175:                "'$this->name'",
176:            );

null

207:            return $child;
208:        }
209:    
210:    
211:        /**
212:         * @param  string|\Closure|null  $targetType  content-type name or modifier closure
213:         */
214:        private function filter(callable $producer, string|\Closure|null $targetType, string $contentType, string $name): void
215:        {
216:            if ($targetType === null || $targetType === $contentType) {
217:                $producer();
218:    
219:            } elseif ($targetType instanceof \Closure) {
220:                echo $targetType($this->capture($producer), $contentType);
221:    

161:            prev($block->functions);
162:        }
163:    
164:    
165:        /**
166:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
167:         * @internal
168:         */
169:        public function renderToContentType(string|\Closure|null $mod, ?string $block = null): void
170:        {
171:            $this->filter(
172:                fn() => $this->render($block),
173:                $mod,
174:                static::ContentType,
175:                "'$this->name'",

'html'

'html'

''/var/www/clients/client1/web1/web/subdom/tmp2/www/themes/frontend/template1/desktop/layouts/parts/shared/main.latte''

100:                }
101:    
102:            } elseif ($this->parentName) { // extends
103:                $this->params = $params;
104:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
105:    
106:            } elseif ($block !== null) { // single block rendering
107:                $this->renderBlock($block, $this->params);
108:    
109:            } else {
110:                $this->main($params);
111:            }
112:        }
113:    
114:    

null

 94:                $this->parentName = ($this->global->coreParentFinder)($this);
 95:            }
 96:    
 97:            if ($this->referenceType === 'import') {
 98:                if ($this->parentName) {
 99:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
100:                }
101:    
102:            } elseif ($this->parentName) { // extends
103:                $this->params = $params;
104:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
105:    
106:            } elseif ($block !== null) { // single block rendering
107:                $this->renderBlock($block, $this->params);
108:    

null

67:    
68:    
69:        /**
70:         * Renders template to output.
71:         * @param  object|mixed[]  $params
72:         */
73:        public function render(string $name, object|array $params = [], ?string $block = null): void
74:        {
75:            $template = $this->createTemplate($name, $this->processParams($params));
76:            $template->global->coreCaptured = false;
77:            $template->render($block);
78:        }
79:    
80:    
81:        /**

null

37:    
38:        /**
39:         * Renders template to output.
40:         */
41:        public function render(?string $file = null, array $params = []): void
42:        {
43:            Nette\Utils\Arrays::toObject($params, $this);
44:            if (isset($this->blueprint)) {
45:                Nodes\TemplatePrintNode::printClass($this->getParameters(), $this->blueprint);
46:            }
47:            $this->latte->render($file ?: $this->file, $this);
48:        }
49:    
50:    
51:        /**

'/var/www/clients/client1/web1/web/subdom/tmp2/app/UI/Front/System/Templates/Page/homepage.latte'

31:            return $this->source;
32:        }
33:    
34:    
35:        /**
36:         * Sends response to output.
37:         */
38:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
39:        {
40:            if ($this->source instanceof Nette\Application\UI\Template) {
41:                $this->source->render();
42:    
43:            } else {
44:                echo $this->source;
45:            }

149:    
150:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
151:            $response = $this->presenter->run(clone $request);
152:    
153:            if ($response instanceof Responses\ForwardResponse) {
154:                $request = $response->getRequest();
155:                goto process;
156:            }
157:    
158:            Arrays::invoke($this->onResponse, $this, $response);
159:            $response->send($this->httpRequest, $this->httpResponse);
160:        }
161:    
162:    
163:        public function createErrorRequest(\Throwable $e): ?Request

67:        }
68:    
69:    
70:        /**
71:         * Dispatch a HTTP request to a front controller.
72:         */
73:        public function run(): void
74:        {
75:            try {
76:                Arrays::invoke($this->onStartup, $this);
77:                $this->processRequest($this->createInitialRequest());
78:                Arrays::invoke($this->onShutdown, $this);
79:    
80:            } catch (\Throwable $e) {
81:                $this->sendHttpCode($e);

 1:    <?php declare(strict_types=1);
 2:    
 3:    use App\Bootstrap;
 4:    
 5:    require __DIR__ . '/../vendor/autoload.php';
 6:    
 7:    $bootstrap = new Bootstrap();
 8:    $container = $bootstrap->bootWebApplication();
 9:    $application = $container->getByType(Nette\Application\Application::class);
10:    $application->run();