445:    
446:                } else {
447:                    if (session_status() === PHP_SESSION_ACTIVE) {
448:                        throw new Nette\InvalidStateException("Unable to set 'session.$key' to value '$value' when session has been started" . ($this->started ? '.' : ' by session.auto_start or session_start().'));
449:                    }
450:    
451:                    if (isset($special[$key])) {
452:                        ("session_$key")($value);
453:    
454:                    } elseif (function_exists('ini_set')) {
455:                        ini_set("session.$key", (string) $value);
456:    
457:                    } else {
458:                        throw new Nette\NotSupportedException("Unable to set 'session.$key' to '$value' because function ini_set() is disabled.");
459:                    }

'session.use_strict_mode'

'1'

77:        {
78:            if (session_status() === PHP_SESSION_ACTIVE) { // adapt an existing session
79:                if (!$this->started) {
80:                    $this->configure(self::SecurityOptions);
81:                    $this->initialize();
82:                }
83:    
84:                return;
85:            }
86:    
87:            $this->configure(self::SecurityOptions + $this->options);
88:    
89:            if (!session_id()) { // session is started for first time
90:                $id = $this->request->getCookie(session_name());
91:                $id = is_string($id) && preg_match('#^[0-9a-zA-Z,-]{22,256}$#Di', $id)

62:            $this->options['cookie_secure'] = &$this->response->cookieSecure;
63:        }
64:    
65:    
66:        /**
67:         * Starts and initializes session data.
68:         * @throws Nette\InvalidStateException
69:         */
70:        public function start(): void
71:        {
72:            $this->doStart();
73:        }
74:    
75:    
76:        private function doStart($mustExists = false): void

30:        public function __construct(string|Stringable|null $errorMessage = null)
31:        {
32:            parent::__construct();
33:            $this->setOmitted()
34:                ->setRequired()
35:                ->addRule(self::Protection, $errorMessage);
36:    
37:            $this->monitor(Presenter::class, function (Presenter $presenter): void {
38:                if (!$this->session) {
39:                    $this->session = $presenter->getSession();
40:                    $this->session->start();
41:                }
42:            });
43:    
44:            $this->monitor(Nette\Forms\Form::class, function (Nette\Forms\Form $form): void {

256:    
257:                        $this->monitors[$type][3] = $rec[3]; // mark as monitored
258:                    }
259:                }
260:            }
261:    
262:            if ($depth === 0) { // call listeners
263:                $prev = [];
264:                foreach ($listeners as $item) {
265:                    if ($item[0] && !in_array($item, $prev, strict: true)) {
266:                        $item[0]($item[1]);
267:                        $prev[] = $item;
268:                    }
269:                }
270:            }

181:                $this->parent = null;
182:    
183:            } else { // add to parent
184:                $this->validateParent($parent);
185:                $this->parent = $parent;
186:                if ($name !== null) {
187:                    $this->name = $name;
188:                }
189:    
190:                $tmp = [];
191:                $this->refreshMonitors(0, $tmp);
192:            }
193:    
194:            return $this;
195:        }

0

73:    
74:                    $tmp[$k] = $v;
75:                }
76:    
77:                $this->components = $tmp;
78:            } else {
79:                $this->components[$name] = $component;
80:            }
81:    
82:            try {
83:                $component->setParent($this, $name);
84:            } catch (\Throwable $e) {
85:                unset($this->components[$name]); // undo
86:                throw $e;
87:            }

'loginForm'

118:                if (!preg_match(self::NameRegexp, $name)) {
119:                    if ($throw) {
120:                        throw new Nette\InvalidArgumentException("Component name must be non-empty alphanumeric string, '$name' given.");
121:                    }
122:    
123:                    return null;
124:                }
125:    
126:                $component = $this->createComponent($name);
127:                if ($component && !isset($this->components[$name])) {
128:                    $this->addComponent($component, $name);
129:                }
130:            }
131:    
132:            $component = $this->components[$name] ?? null;

'loginForm'

30:    
31:    
32:        /**
33:         * Returns component specified by name. Throws exception if component doesn't exist.
34:         * @param  string|int  $name
35:         * @throws Nette\InvalidArgumentException
36:         */
37:        public function offsetGet($name): IComponent
38:        {
39:            $name = is_int($name) ? (string) $name : $name;
40:            return $this->getComponent($name);
41:        }
42:    
43:    
44:        /**

'loginForm'

148:                }
149:    
150:            } elseif ($this->parentName) { // extends
151:                $this->params = $params;
152:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
153:    
154:            } elseif ($block !== null) { // single block rendering
155:                $this->renderBlock($block, $this->params);
156:    
157:            } else {
158:                $this->main($params);
159:            }
160:        }
161:    
162:    

null

142:                $this->parentName = ($this->global->coreParentFinder)($this);
143:            }
144:    
145:            if ($this->referenceType === 'import') {
146:                if ($this->parentName) {
147:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
148:                }
149:    
150:            } elseif ($this->parentName) { // extends
151:                $this->params = $params;
152:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
153:    
154:            } elseif ($block !== null) { // single block rendering
155:                $this->renderBlock($block, $this->params);
156:    

null

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

null

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

'/var/www/clients/client1/web76/private/app/FrontModule/templates/Login/default.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:            }

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

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

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