37:    
38:    
39:        private function open(): void
40:        {
41:            if ($this->path !== ':memory:' && !is_file($this->path)) {
42:                touch($this->path); // ensures ordinary file permissions
43:            }
44:    
45:            $this->pdo = new \PDO('sqlite:' . $this->path);
46:            $this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
47:            $this->pdo->exec('
48:                PRAGMA foreign_keys = OFF;
49:                PRAGMA journal_mode = WAL;
50:                CREATE TABLE IF NOT EXISTS tags (
51:                    key BLOB NOT NULL,

59:                CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_key_tag ON tags(key, tag);
60:                CREATE UNIQUE INDEX IF NOT EXISTS idx_priorities_key ON priorities(key);
61:                CREATE INDEX IF NOT EXISTS idx_priorities_priority ON priorities(priority);
62:            ');
63:        }
64:    
65:    
66:        public function write(string $key, array $dependencies): void
67:        {
68:            if (!$this->pdo) {
69:                $this->open();
70:            }
71:            $this->pdo->exec('BEGIN');
72:    
73:            if (!empty($dependencies[Cache::TAGS])) {

177:            }
178:            $handle = $this->locks[$key];
179:            unset($this->locks[$key]);
180:    
181:            $cacheFile = $this->getCacheFile($key);
182:    
183:            if (isset($dp[Cache::TAGS]) || isset($dp[Cache::PRIORITY])) {
184:                if (!$this->journal) {
185:                    throw new Nette\InvalidStateException('CacheJournal has not been provided.');
186:                }
187:                $this->journal->write($cacheFile, $dp);
188:            }
189:    
190:            ftruncate($handle, 0);
191:    

172:                }
173:            }
174:    
175:            if ($data === null) {
176:                $this->storage->remove($key);
177:            } else {
178:                $dependencies = $this->completeDependencies($dependencies);
179:                if (isset($dependencies[self::EXPIRATION]) && $dependencies[self::EXPIRATION] <= 0) {
180:                    $this->storage->remove($key);
181:                } else {
182:                    $this->storage->write($key, $data, $dependencies);
183:                }
184:                return $data;
185:            }
186:        }

30:    
31:            $cache->save($this->languageId, $this->texts, array(CACHE::TAGS => array($this->getShortName())));
32:        }
33:    
34:        /**
35:         * @param $code
36:         * @return null
37:         */
38:        public function get($code)
39:        {
40:            $this->loadTexts();
41:            /*
42:            \Tracy\Debugger::barDump($this->language_id);
43:            \Tracy\Debugger::barDump($code);
44:            \Tracy\Debugger::barDump($this->texts[$code]);

30:        }
31:    
32:        public function getTitleInternal()
33:        {
34:            return $this->item->title_internal;
35:        }
36:    
37:        public function getDescription(TextRepository $textRepository)
38:        {
39:            if ($this->item->description_text_id) {
40:                return $textRepository->get($this->item->ref('text', 'description_text_id')->code);
41:            } else {
42:                return $this->item->description;
43:            }
44:        }

108:                }
109:    
110:                $this->saveShareImage($userresult);
111:    
112:                $this->template->shareTitle = $this->template->pageTitle = $this->application->item->title;
113:                $this->template->shareDescription = $this->template->pageDescription = $userresult->getTitle($this->translator);
114:                $this->template->pageImage = $userresult->getShareImageUrl($this->getHttpRequest());
115:    
116:            } catch (NoUserresultException $exception) {
117:                $this->template->shareTitle = $this->template->pageTitle = $this->application->item->title;
118:                $this->template->shareDescription = $this->template->pageDescription = $this->application->getDescription($this->text_repository);
119:                $this->template->pageImage = $this->getHttpRequest()->getUrl()->getHostUrl() . Thumbnail::getUrl(DIR_IMAGES . DIRECTORY_SEPARATOR . ApplicationRepository::DIR_IMAGES . DIRECTORY_SEPARATOR . $this->application->item->share_image);
120:            }
121:    
122:    //            $this->translator->translate('')

 92:            $rc = $this->getReflection();
 93:            if ($rc->hasMethod($method)) {
 94:                $rm = $rc->getMethod($method);
 95:                if ($rm->isPublic() && !$rm->isAbstract() && !$rm->isStatic()) {
 96:                    $this->checkRequirements($rm);
 97:                    try {
 98:                        $args = $rc->combineArgs($rm, $params);
 99:                    } catch (Nette\InvalidArgumentException $e) {
100:                        throw new Nette\Application\BadRequestException($e->getMessage());
101:                    }
102:                    $rm->invokeArgs($this, $args);
103:                    return true;
104:                }
105:            }
106:            return false;

225:                }
226:    
227:                // SIGNAL HANDLING
228:                // calls $this->handle<Signal>()
229:                $this->processSignal();
230:    
231:                // RENDERING VIEW
232:                $this->beforeRender();
233:                $this->onRender($this);
234:                // calls $this->render<View>()
235:                $this->tryCall(static::formatRenderMethod($this->view), $this->params);
236:                $this->afterRender();
237:    
238:                // save component tree persistent state
239:                $this->saveGlobalState();

141:            if (!$request->isMethod($request::FORWARD) && !strcasecmp($request->getPresenterName(), (string) $this->errorPresenter)) {
142:                throw new BadRequestException('Invalid request. Presenter is not achievable.');
143:            }
144:    
145:            try {
146:                $this->presenter = $this->presenterFactory->createPresenter($request->getPresenterName());
147:            } catch (InvalidPresenterException $e) {
148:                throw count($this->requests) > 1 ? $e : new BadRequestException($e->getMessage(), 0, $e);
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;

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);

66:    }
67:    
68:    
69:    // RUN
70:    require __DIR__ . '/../vendor/autoload.php';
71:    Debugger::$maxDepth = 7;
72:    Debugger::$maxLength = 500;
73:    App\Bootstrap::boot()
74:        ->createContainer()
75:        ->getByType(Nette\Application\Application::class)
76:        ->run();
77: