172:        /**
173:         * @return Exception
174:         */
175:        private static function wrapException(Driver $driver, Throwable $driverEx, string $msg)
176:        {
177:            if ($driverEx instanceof DriverException) {
178:                return $driverEx;
179:            }
180:    
181:            if ($driver instanceof ExceptionConverterDriver && $driverEx instanceof DeprecatedDriverException) {
182:                return $driver->convertException($msg, $driverEx);
183:            }
184:    
185:            return new Exception($msg, 0, $driverEx);
186:        }

'An exception occurred in driver: SQLSTATE[HY000] [2002] Connection refused'

159:            return self::wrapException($driver, $driverEx, $msg);
160:        }
161:    
162:        /**
163:         * @deprecated
164:         *
165:         * @return Exception
166:         */
167:        public static function driverException(Driver $driver, Throwable $driverEx)
168:        {
169:            return self::wrapException($driver, $driverEx, 'An exception occurred in driver: ' . $driverEx->getMessage());
170:        }
171:    
172:        /**
173:         * @return Exception

'An exception occurred in driver: SQLSTATE[HY000] [2002] Connection refused'

21:        public function connect(array $params, $username = null, $password = null, array $driverOptions = [])
22:        {
23:            try {
24:                $conn = new PDO\Connection(
25:                    $this->constructPdoDsn($params),
26:                    $username,
27:                    $password,
28:                    $driverOptions
29:                );
30:            } catch (PDOException $e) {
31:                throw Exception::driverException($this, $e);
32:            }
33:    
34:            return $conn;
35:        }

402:        public function connect()
403:        {
404:            if ($this->_conn !== null) {
405:                return false;
406:            }
407:    
408:            $driverOptions = $this->params['driverOptions'] ?? [];
409:            $user          = $this->params['user'] ?? null;
410:            $password      = $this->params['password'] ?? null;
411:    
412:            $this->_conn = $this->_driver->connect($this->params, $user, $password, $driverOptions);
413:    
414:            $this->transactionNestingLevel = 0;
415:    
416:            if ($this->autoCommit === false) {

'mujed_cz'

array (0)

465:            }
466:    
467:            // Explicit platform version requested (supersedes auto-detection).
468:            if (isset($this->params['serverVersion'])) {
469:                return $this->params['serverVersion'];
470:            }
471:    
472:            // If not connected, we need to connect now to determine the platform version.
473:            if ($this->_conn === null) {
474:                try {
475:                    $this->connect();
476:                } catch (Throwable $originalException) {
477:                    if (empty($this->params['dbname'])) {
478:                        throw $originalException;
479:                    }

427:    
428:        /**
429:         * Detects and sets the database platform.
430:         *
431:         * Evaluates custom platform class and version in order to set the correct platform.
432:         *
433:         * @throws Exception If an invalid platform was specified for this connection.
434:         */
435:        private function detectDatabasePlatform(): AbstractPlatform
436:        {
437:            $version = $this->getDatabasePlatformVersion();
438:    
439:            if ($version !== null) {
440:                assert($this->_driver instanceof VersionAwarePlatformDriver);
441:    

369:        /**
370:         * Gets the DatabasePlatform for the connection.
371:         *
372:         * @return AbstractPlatform
373:         *
374:         * @throws Exception
375:         */
376:        public function getDatabasePlatform()
377:        {
378:            if ($this->platform === null) {
379:                $this->platform = $this->detectDatabasePlatform();
380:                $this->platform->setEventManager($this->_eventManager);
381:            }
382:    
383:            return $this->platform;

201:    
202:        /**
203:         * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
204:         * and persists instances of the class described by the given ClassMetadata descriptor.
205:         */
206:        public function __construct(EntityManagerInterface $em, ClassMetadata $class)
207:        {
208:            $this->em                    = $em;
209:            $this->class                 = $class;
210:            $this->conn                  = $em->getConnection();
211:            $this->platform              = $this->conn->getDatabasePlatform();
212:            $this->quoteStrategy         = $em->getConfiguration()->getQuoteStrategy();
213:            $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
214:            $this->noLimitsContext       = $this->currentPersisterContext = new CachedPersisterContext(
215:                $class,

3501:        public function getEntityPersister($entityName)
3502:        {
3503:            if (isset($this->persisters[$entityName])) {
3504:                return $this->persisters[$entityName];
3505:            }
3506:    
3507:            $class = $this->em->getClassMetadata($entityName);
3508:    
3509:            switch (true) {
3510:                case $class->isInheritanceTypeNone():
3511:                    $persister = new BasicEntityPersister($this->em, $class);
3512:                    break;
3513:    
3514:                case $class->isInheritanceTypeSingleTable():
3515:                    $persister = new SingleTablePersister($this->em, $class);

229:         * Finds a single entity by a set of criteria.
230:         *
231:         * @psalm-param array<string, mixed> $criteria
232:         * @psalm-param array<string, string>|null $orderBy
233:         *
234:         * @return object|null The entity instance or NULL if the entity can not be found.
235:         * @psalm-return ?T
236:         */
237:        public function findOneBy(array $criteria, ?array $orderBy = null)
238:        {
239:            $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
240:    
241:            return $persister->load($criteria, null, null, [], null, 1, $orderBy);
242:        }
243:    

'MujEd\Service\Entity\Service'

31:    
32:            if (!$employee) {
33:                throw new ServiceNotFoundException(sprintf('Service with id %s not found', $uuid->toString()));
34:            }
35:    
36:            return $employee;
37:        }
38:    
39:        public function findOneBy(array $criteria, ?array $order = null): ?Service
40:        {
41:            return $this->entityManager->getRepository(Service::class)->findOneBy($criteria, $order);
42:        }
43:    
44:        public function findServices(array $criteria, ?array $notOrdered = null, ?string $buildingPhase = null, ?array $servicesId = null): array
45:        {

null

74:    
75:                $this->template->client = $this->clientRepository->getByUuid(Uuid::fromString($this->presenter->user->getId()));
76:            } else {
77:                $this->template->notifications = 0;
78:            }
79:    
80:            $this->template->micromodalTriggers['finished'] = $this->getMicroModalTrigger(null, 'finished');
81:            $this->template->micromodalTriggers['unfinished'] = $this->getMicroModalTrigger(null, 'unfinished');
82:            $this->template->micromodalTriggers['tools'] = $this->getMicroModalTrigger();
83:    
84:            $this->template->heatLossService = $this->serviceRepository->findOneBy(['modalId' => 'heat-loss-modal']);
85:            $this->template->consumptionService = $this->serviceRepository->findOneBy(['modalId' => 'consumption-calculation-modal']);
86:            $this->template->priceOfferService = $this->serviceRepository->findOneBy(['modalId' => 'price-offers-modal']);
87:    
88:            $this->template->render();

299:    
300:            if (!$block) {
301:                $hint = ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
302:                    ? ", did you mean '$t'?"
303:                    : '.';
304:                $name = $layer ? "$layer $name" : $name;
305:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
306:            }
307:    
308:            $this->filter(
309:                function () use ($block, $params): void { reset($block->functions)($params); },
310:                $mod,
311:                $block->contentType,
312:                "block $name"
313:            );

null

354:            $block->functions = array_merge($block->functions, $functions);
355:        }
356:    
357:    
358:        /**
359:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
360:         */
361:        private function filter(callable $function, $mod, string $contentType, string $name): void
362:        {
363:            if ($mod === null || $mod === $contentType) {
364:                $function();
365:    
366:            } elseif ($mod instanceof \Closure) {
367:                echo $mod($this->capture($function), $contentType);
368:    

298:                : ($this->blocks[self::LAYER_LOCAL][$name] ?? $this->blocks[self::LAYER_TOP][$name] ?? null);
299:    
300:            if (!$block) {
301:                $hint = ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
302:                    ? ", did you mean '$t'?"
303:                    : '.';
304:                $name = $layer ? "$layer $name" : $name;
305:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
306:            }
307:    
308:            $this->filter(
309:                function () use ($block, $params): void { reset($block->functions)($params); },
310:                $mod,
311:                $block->contentType,
312:                "block $name"

null

'html'

'block menu'

161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {
175:                while (ob_get_level() > $level) {

193:    
194:            if ($this->referenceType === 'import') {
195:                if ($this->parentName) {
196:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
197:                }
198:    
199:            } elseif ($this->parentName) { // extends
200:                ob_start(function () {});
201:                $this->params = $this->main();
202:                ob_end_clean();
203:                $this->createTemplate($this->parentName, $this->params, 'extends')->render($block);
204:    
205:            } elseif ($block !== null) { // single block rendering
206:                $this->renderBlock($block, $this->params);
207:    

null

160:    
161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {

null

 92:    
 93:        /**
 94:         * Renders template to output.
 95:         * @param  object|mixed[]  $params
 96:         */
 97:        public function render(string $name, $params = [], ?string $block = null): void
 98:        {
 99:            $template = $this->createTemplate($name, $this->processParams($params));
100:            $template->global->coreCaptured = false;
101:            ($this->probe)($template);
102:            $template->render($block);
103:        }
104:    
105:    
106:        /**

null

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

'/srv/app/FrontModule/Presenters/templates/Sign/frontLogin.latte'

40:            return $this->source;
41:        }
42:    
43:    
44:        /**
45:         * Sends response to output.
46:         */
47:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
48:        {
49:            if ($this->source instanceof Nette\Application\UI\Template) {
50:                $this->source->render();
51:    
52:            } else {
53:                echo $this->source;
54:            }

161:    
162:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
163:            $response = $this->presenter->run(clone $request);
164:    
165:            if ($response instanceof Responses\ForwardResponse) {
166:                $request = $response->getRequest();
167:                goto process;
168:            }
169:    
170:            Arrays::invoke($this->onResponse, $this, $response);
171:            $response->send($this->httpRequest, $this->httpResponse);
172:        }
173:    
174:    
175:        public function processException(\Throwable $e): void

80:        }
81:    
82:    
83:        /**
84:         * Dispatch a HTTP request to a front controller.
85:         */
86:        public function run(): void
87:        {
88:            try {
89:                Arrays::invoke($this->onStartup, $this);
90:                $this->processRequest($this->createInitialRequest());
91:                Arrays::invoke($this->onShutdown, $this);
92:    
93:            } catch (\Throwable $e) {
94:                Arrays::invoke($this->onError, $this, $e);

29:    }
30:    
31:    require __DIR__.'/../vendor/autoload.php';
32:    
33:    $isApi = substr($_SERVER['REQUEST_URI'], 0, 4) === '/api';
34:    $container = Bootstrap::boot()->createContainer();
35:    
36:    if ($isApi) {
37:        $container->getByType(ApiApplication::class)->run();
38:    } else {
39:        $container->getByType(UIApplication::class)->run();
40:    }