216:        }
217:    
218:    
219:        /**
220:         * Adds the specified component to the IContainer.
221:         * @return static
222:         * @throws Nette\InvalidStateException
223:         */
224:        public function addComponent(Nette\ComponentModel\IComponent $component, ?string $name, string $insertBefore = null)
225:        {
226:            parent::addComponent($component, $name, $insertBefore);
227:            if ($this->currentGroup !== null) {
228:                $this->currentGroup->add($component);
229:            }
230:            return $this;

'_token_'

'_token_'

213:            return $this;
214:        }
215:    
216:    
217:        /**
218:         * Cross-Site Request Forgery (CSRF) form protection.
219:         */
220:        public function addProtection(string $errorMessage = null): Controls\CsrfProtection
221:        {
222:            $control = new Controls\CsrfProtection($errorMessage);
223:            $this->addComponent($control, self::PROTECTOR_ID, key((array) $this->getComponents()));
224:            return $control;
225:        }
226:    
227:    

'_token_'

'_token_'

21:            $this->userManager = new \App\FrontModule\Model\UserManager($this->database, $this->user);
22:    
23:            $this->singleAuthorizationManager = new \App\FrontModule\Model\SingleAuthorizationManager($this->database, 
24:                    $this->user, $this->applicationInterface);
25:        }
26:    
27:    
28:        protected function createComponentForgottenPasswordForm()
29:        {
30:            $factory = new \App\FrontModule\Forms\SignForgottenPasswordFormFactory($this->userManager);
31:            $form = $factory->create()->setTranslator($this->basicTranslator);
32:            $form->onSuccess[] = array($this, 'forgottenPasswordFormSucceeded');
33:    
34:            return $form;
35:        }

153:         */
154:        protected function createComponent(string $name): ?IComponent
155:        {
156:            $ucname = ucfirst($name);
157:            $method = 'createComponent' . $ucname;
158:            if (
159:                $ucname !== $name
160:                && method_exists($this, $method)
161:                && (new \ReflectionMethod($this, $method))->getName() === $method
162:            ) {
163:                $component = $this->$method($name);
164:                if (!$component instanceof IComponent && !isset($this->components[$name])) {
165:                    $class = static::class;
166:                    throw new Nette\UnexpectedValueException("Method $class::$method() did not return or create the desired component.");
167:                }

'forgottenPasswordForm'

398:                    /*case 'FileContactForm':
399:                        $baseContactFormControl = new \App\FrontModule\Model\FileContactFormControl($this->database, $this->user, 
400:                                $this->applicationInterface, $this->basicTranslator);
401:                        $baseContactFormControl->create($matches[1]);
402:                        return $baseContactFormControl;
403:    
404:                        break;*/
405:                }
406:            }
407:    
408:            return parent::createComponent($name);
409:        }
410:    
411:    
412:        /*protected function createComponentEuCookiesForm()

'forgottenPasswordForm'

112:            [$name] = $parts = explode(self::NAME_SEPARATOR, $name, 2);
113:    
114:            if (!isset($this->components[$name])) {
115:                if (!preg_match(self::NAME_REGEXP, $name)) {
116:                    if ($throw) {
117:                        throw new Nette\InvalidArgumentException("Component name must be non-empty alphanumeric string, '$name' given.");
118:                    }
119:                    return null;
120:                }
121:    
122:                $component = $this->createComponent($name);
123:                if ($component && !isset($this->components[$name])) {
124:                    $this->addComponent($component, $name);
125:                }
126:            }

'forgottenPasswordForm'

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

'forgottenPasswordForm'

85:        {
86:            extract($this->params);
87:            extract($ʟ_args);
88:            unset($ʟ_args);
89:            echo "\n";
90:            $this->renderBlock('title', get_defined_vars()) /* line 14 */;
91:            echo '    <div class="order-content-wrapper step-2">
92:            <div class="personal-data-wrapper">
93:                ';
94:            /* line 17 */
95:            echo Nette\Bridges\FormsLatte\Runtime::renderFormBegin($form = $_form = $this->global->formsStack[] = $this->global->uiControl["forgottenPasswordForm"], []);
96:            echo "\n";
97:            if ($form->hasErrors()) /* line 18 */ {
98:                echo '                <div class="flash error">
99:                        <p class="flash-title">';

'forgottenPasswordForm'

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:    

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:            );
314:        }
315:    
316:    

'html'

'html'

'block content'

331:                            <div class="column second">
332:                                ';
333:                                    echo ($this->filters->translate)('Base:presenter:homepage-dotaznik-fourth-past') /* line 172 */;
334:                                    echo '
335:                            </div>
336:                        </div>
337:                    </div>
338:    
339:    ';
340:                                }
341:                                $this->renderBlock('content', [], 'html') /* line 243 */;
342:                            } finally {
343:                                $ʟ_ifc[3] = rtrim(ob_get_flush()) === '';
344:                            }
345:                            echo '        </div>

'content'

array (0)

'html'

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

40:        {
41:            return $this->latte;
42:        }
43:    
44:    
45:        /**
46:         * Renders template to output.
47:         */
48:        public function render(string $file = null, array $params = []): void
49:        {
50:            $this->latte->render($file ?: $this->file, $params + $this->params);
51:        }
52:    
53:    
54:        /**

'/var/www/clients/client0/web36/web/app/FrontModule/templates/Sign/forgottenPassword.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\ITemplate) {
50:                $this->source->render();
51:    
52:            } else {
53:                echo $this->source;
54:            }

149:            }
150:            $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:            $this->onResponse($this, $response);
159:            $response->send($this->httpRequest, $this->httpResponse);
160:        }
161:    
162:    
163:        public function processException(\Throwable $e): void

75:        }
76:    
77:    
78:        /**
79:         * Dispatch a HTTP request to a front controller.
80:         */
81:        public function run(): void
82:        {
83:            try {
84:                $this->onStartup($this);
85:                $this->processRequest($this->createInitialRequest());
86:                $this->onShutdown($this);
87:    
88:            } catch (\Throwable $e) {
89:                $this->onError($this, $e);

 1:    <?php
 2:    
 3:    error_reporting(~E_USER_DEPRECATED);
 4:    // Uncomment this line if you must temporarily take down your site for maintenance.
 5:    // require __DIR__ . '/.maintenance.php';
 6:    
 7:    $container = require __DIR__ . '/../app/bootstrap.php';
 8:    
 9:    $container->getByType('Nette\Application\Application')->run();
10: