ini_set(): Session ini settings cannot be changed after headers have already been sent search► skip error►

457:    
458:                } else {
459:                    if (session_status() === PHP_SESSION_ACTIVE) {
460:                        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().'));
461:                    }
462:    
463:                    if (isset($special[$key])) {
464:                        ("session_$key")($value);
465:    
466:                    } elseif (function_exists('ini_set')) {
467:                        ini_set("session.$key", (string) $value);
468:    
469:                    } else {
470:                        throw new Nette\NotSupportedException("Unable to set 'session.$key' to '$value' because function ini_set() is disabled.");
471:                    }

'session.use_strict_mode'

'1'

 93:        {
 94:            if (session_status() === PHP_SESSION_ACTIVE) { // adapt an existing session
 95:                if (!$this->started) {
 96:                    $this->configure(self::SecurityOptions);
 97:                    $this->initialize();
 98:                }
 99:    
100:                return;
101:            }
102:    
103:            $this->configure(self::SecurityOptions + $this->options);
104:    
105:            if (!session_id()) { // session is started for first time
106:                $id = $this->request->getCookie(session_name());
107:                $id = is_string($id) && preg_match('#^[0-9a-zA-Z,-]{22,256}$#Di', $id)

78:            $this->options['cookie_secure'] = &$this->response->cookieSecure;
79:        }
80:    
81:    
82:        /**
83:         * Starts and initializes session data.
84:         * @throws Nette\InvalidStateException
85:         */
86:        public function start(): void
87:        {
88:            $this->doStart();
89:        }
90:    
91:    
92:        private function doStart($mustExists = false): void

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

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

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

0

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

'signInForm'

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

'signInForm'

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:        /**

'signInForm'

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

null

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

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:        /**

'/var/www/html/app/Components/Forms/templates/signInForm.latte'

67:            $form->onSuccess[] = $this->formSucceeded(...);
68:            return $form;
69:        }
70:    
71:        /**
72:         * The render method
73:         * @return void
74:         */
75:        public function render(): void
76:        {
77:            $this->template->render(__DIR__.'/templates/signInForm.latte');
78:        }
79:    
80:        /**
81:         * Form processing method

'/var/www/html/app/Components/Forms/templates/signInForm.latte'

243:    
244:            if (!$block) {
245:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
246:                    ? ", did you mean '$t'?"
247:                    : '.';
248:                $name = $layer ? "$layer $name" : $name;
249:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
250:            }
251:    
252:            $this->filter(
253:                fn() => reset($block->functions)($params),
254:                $mod,
255:                $block->contentType,
256:                "block $name",
257:            );

null

302:            $block->functions = array_merge($block->functions, $functions);
303:        }
304:    
305:    
306:        /**
307:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
308:         */
309:        private function filter(callable $function, string|\Closure|null $mod, string $contentType, string $name): void
310:        {
311:            if ($mod === null || $mod === $contentType) {
312:                $function();
313:    
314:            } elseif ($mod instanceof \Closure) {
315:                echo $mod($this->capture($function), $contentType);
316:    

242:                : ($this->blocks[self::LayerLocal][$name] ?? $this->blocks[self::LayerTop][$name] ?? null);
243:    
244:            if (!$block) {
245:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
246:                    ? ", did you mean '$t'?"
247:                    : '.';
248:                $name = $layer ? "$layer $name" : $name;
249:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
250:            }
251:    
252:            $this->filter(
253:                fn() => reset($block->functions)($params),
254:                $mod,
255:                $block->contentType,
256:                "block $name",

'html'

'html'

'block content'

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

null

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

null

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

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:        /**

'/var/www/html/app/Module/Presenters/templates/Sign/in.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);

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