60:        public function connect()
61:        {
62:            if ($this->pdo) {
63:                return;
64:            }
65:    
66:            try {
67:                $this->pdo = new PDO($this->params[0], $this->params[1], $this->params[2], $this->options);
68:                $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
69:            } catch (PDOException $e) {
70:                throw ConnectionException::from($e);
71:            }
72:    
73:            $class = empty($this->options['driverClass'])
74:                ? 'Nette\Database\Drivers\\' . ucfirst(str_replace('sql', 'Sql', $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME))) . 'Driver'

105:        public function getPdo()
106:        {
107:            $this->connect();
108:            return $this->pdo;
109:        }
110:    
111:    
112:        /** @return ISupplementalDriver */
113:        public function getSupplementalDriver()
114:        {
115:            $this->connect();
116:            return $this->driver;
117:        }
118:    
119:    

186:    
187:            $this->structure = $this->cache->load('structure', [$this, 'loadStructure']);
188:        }
189:    
190:    
191:        /**
192:         * @internal
193:         */
194:        public function loadStructure()
195:        {
196:            $driver = $this->connection->getSupplementalDriver();
197:    
198:            $structure = [];
199:            $structure['tables'] = $driver->getTables();
200:    

83:         * Reads the specified item from the cache or generate it.
84:         * @param  mixed
85:         * @param  callable
86:         * @return mixed
87:         */
88:        public function load($key, $fallback = NULL)
89:        {
90:            $data = $this->storage->read($this->generateKey($key));
91:            if ($data === NULL && $fallback) {
92:                return $this->save($key, function (&$dependencies) use ($fallback) {
93:                    return call_user_func_array($fallback, [&$dependencies]);
94:                });
95:            }
96:            return $data;
97:        }

165:        public function save($key, $data, array $dependencies = NULL)
166:        {
167:            $key = $this->generateKey($key);
168:    
169:            if ($data instanceof Nette\Callback || $data instanceof \Closure) {
170:                if ($data instanceof Nette\Callback) {
171:                    trigger_error('Nette\Callback is deprecated, use closure or Nette\Utils\Callback::toClosure().', E_USER_DEPRECATED);
172:                }
173:                $this->storage->lock($key);
174:                try {
175:                    $data = call_user_func_array($data, [&$dependencies]);
176:                } catch (\Throwable $e) {
177:                    $this->storage->remove($key);
178:                    throw $e;
179:                } catch (\Exception $e) {

84:         * @param  mixed
85:         * @param  callable
86:         * @return mixed
87:         */
88:        public function load($key, $fallback = NULL)
89:        {
90:            $data = $this->storage->read($this->generateKey($key));
91:            if ($data === NULL && $fallback) {
92:                return $this->save($key, function (&$dependencies) use ($fallback) {
93:                    return call_user_func_array($fallback, [&$dependencies]);
94:                });
95:            }
96:            return $data;
97:        }
98:    

177:            return $this->isRebuilt;
178:        }
179:    
180:    
181:        protected function needStructure()
182:        {
183:            if ($this->structure !== NULL) {
184:                return;
185:            }
186:    
187:            $this->structure = $this->cache->load('structure', [$this, 'loadStructure']);
188:        }
189:    
190:    
191:        /**

48:        {
49:            $this->needStructure();
50:            $table = $this->resolveFQTableName($table);
51:    
52:            return $this->structure['columns'][$table];
53:        }
54:    
55:    
56:        public function getPrimaryKey($table)
57:        {
58:            $this->needStructure();
59:            $table = $this->resolveFQTableName($table);
60:    
61:            if (!isset($this->structure['primary'][$table])) {
62:                return NULL;

21:    
22:    
23:        public function __construct(IStructure $structure)
24:        {
25:            $this->structure = $structure;
26:        }
27:    
28:    
29:        public function getPrimary($table)
30:        {
31:            return $this->structure->getPrimaryKey($table);
32:        }
33:    
34:    
35:        public function getHasManyReference($nsTable, $key)

85:         * @param  string  table name
86:         * @param  Nette\Caching\IStorage|NULL
87:         */
88:        public function __construct(Context $context, IConventions $conventions, $tableName, Nette\Caching\IStorage $cacheStorage = NULL)
89:        {
90:            $this->context = $context;
91:            $this->conventions = $conventions;
92:            $this->name = $tableName;
93:    
94:            $this->cache = $cacheStorage ? new Nette\Caching\Cache($cacheStorage, 'Nette.Database.' . md5($context->getConnection()->getDsn())) : NULL;
95:            $this->primary = $conventions->getPrimary($tableName);
96:            $this->sqlBuilder = new SqlBuilder($tableName, $context);
97:            $this->refCache = &$this->getRefTable($refPath)->globalRefCache[$refPath];
98:        }
99:    

 91:            return $this->connection->query($sql, ...$params);
 92:        }
 93:    
 94:    
 95:        /**
 96:         * @param  string
 97:         * @return Table\Selection
 98:         */
 99:        public function table($table)
100:        {
101:            return new Table\Selection($this, $this->conventions, $table, $this->cacheStorage);
102:        }
103:    
104:    
105:        /** @return Connection */

41:            return TableInfo::get($this->className);
42:        }
43:        
44:        public function newTable($tableName = null)
45:        {
46:            return $this->getDb()->table($tableName ?: $this->tableInfo->tableName);
47:        }
48:        
49:        public function getBy($params)
50:        {
51:            $sel = $this->newTable();
52:            foreach($params as $k => $v)
53:            {
54:                if (is_int($k))
55:                    $sel->where($v);

41:            return $this->_dbEntity->toArray($cols, $fkObjects, $prefix);
42:        }
43:        
44:        public static function get($pk, $db = null)
45:        {
46:            return self::repository($db)->get($pk, $db);
47:        }
48:        
49:        public static function getBy($filter, $db = null)
50:        {
51:            return self::repository($db)->getBy($filter);
52:        }
53:        
54:        public static function findBy($filter, $db = null)
55:        {

10:    * @property json $value
11:    */
12:    class AppVar extends BaseModel 
13:    {
14:        protected static $cache = array();
15:        
16:        public static function getCachedValue($code) 
17:        {
18:            if (!array_key_exists($code, self::$cache))
19:            {
20:                $ent = self::getBy(['code' => $code]);
21:                if ($ent == null)
22:                {
23:                    self::$cache[$code] = null; // throw new OutOfBoundsException("No AppVar with code '$code'");
24:                } 

24:                } 
25:                else 
26:                {
27:                    self::$cache[$code] = $ent->value;
28:                }
29:            }
30:            return self::$cache[$code];
31:        }
32:        public static function v($code)
33:        {
34:            return self::getCachedValue($code);
35:        }
36:    }
37:    

48:                $res[''.$k] = $v;
49:            }
50:    
51:            return $res;
52:        }
53:    
54:        public function __construct($opt = [])
55:        {
56:            if (is_string($opt))
57:            {
58:                $opt = AppVar::v($opt);
59:            }
60:            foreach($opt as $k => $v)
61:                $this->{$k} = $v;
62:        }

747:    
748:        public function createServiceUserManager(): App\Model\UserManager
749:        {
750:            $service = new App\Model\UserManager($this->getService('database.default.context'));
751:            return $service;
752:        }
753:    
754:    
755:        public function createServiceViewConfig(): App\ViewConfig
756:        {
757:            $service = new App\ViewConfig('viewConfig');
758:            return $service;
759:        }
760:    
761:    

169:            $method = self::getMethodName($name);
170:            if (isset($this->creating[$name])) {
171:                throw new Nette\InvalidStateException(sprintf('Circular reference detected for services: %s.', implode(', ', array_keys($this->creating))));
172:    
173:            } elseif (!method_exists($this, $method) || (new \ReflectionMethod($this, $method))->getName() !== $method) {
174:                throw new MissingServiceException("Service '$name' not found.");
175:            }
176:    
177:            try {
178:                $this->creating[$name] = TRUE;
179:                $service = $this->$method(...$args);
180:    
181:            } finally {
182:                unset($this->creating[$name]);
183:            }

 95:         * @param  string
 96:         * @return object
 97:         * @throws MissingServiceException
 98:         */
 99:        public function getService($name)
100:        {
101:            if (!isset($this->registry[$name])) {
102:                if (isset($this->meta[self::ALIASES][$name])) {
103:                    return $this->getService($this->meta[self::ALIASES][$name]);
104:                }
105:                $this->registry[$name] = $this->createService($name);
106:            }
107:            return $this->registry[$name];
108:        }
109:    

387:        }
388:    
389:    
390:        public function createServiceApplication__3(): App\Presenters\ErrorPresenter
391:        {
392:            $service = new App\Presenters\ErrorPresenter($this->getService('tracy.logger'));
393:            $service->injectPrimary($this, $this->getService('application.presenterFactory'),
394:                $this->getService('routing.router'), $this->getService('http.request'),
395:                $this->getService('http.response'), $this->getService('session.session'),
396:                $this->getService('security.user'), $this->getService('latte.templateFactory'));
397:            $service->viewConfig = $this->getService('viewConfig');
398:            $service->response = $this->getService('http.response');
399:            $service->httpRequest = $this->getService('http.request');
400:            $service->currentCustomer = $this->getService('26_App_CurrentCustomer');
401:            $service->invalidLinkMode = 1;

169:            $method = self::getMethodName($name);
170:            if (isset($this->creating[$name])) {
171:                throw new Nette\InvalidStateException(sprintf('Circular reference detected for services: %s.', implode(', ', array_keys($this->creating))));
172:    
173:            } elseif (!method_exists($this, $method) || (new \ReflectionMethod($this, $method))->getName() !== $method) {
174:                throw new MissingServiceException("Service '$name' not found.");
175:            }
176:    
177:            try {
178:                $this->creating[$name] = TRUE;
179:                $service = $this->$method(...$args);
180:    
181:            } finally {
182:                unset($this->creating[$name]);
183:            }

49:                }
50:    
51:                $presenter = $this->container->createInstance($class);
52:                $this->container->callInjects($presenter);
53:                if ($presenter instanceof Nette\Application\UI\Presenter && $presenter->invalidLinkMode === NULL) {
54:                    $presenter->invalidLinkMode = $this->invalidLinkMode;
55:                }
56:                return $presenter;
57:            }
58:    
59:            return $this->container->createService($services[0]);
60:        }
61:    
62:    }
63:    

39:        }
40:    
41:    
42:        /**
43:         * Creates new presenter instance.
44:         * @param  string  presenter name
45:         * @return IPresenter
46:         */
47:        public function createPresenter($name)
48:        {
49:            return call_user_func($this->factory, $this->getPresenterClass($name));
50:        }
51:    
52:    
53:        /**

130:            }
131:    
132:            $this->requests[] = $request;
133:            $this->onRequest($this, $request);
134:    
135:            if (!$request->isMethod($request::FORWARD) && !strcasecmp($request->getPresenterName(), $this->errorPresenter)) {
136:                throw new BadRequestException('Invalid request. Presenter is not achievable.');
137:            }
138:    
139:            try {
140:                $this->presenter = $this->presenterFactory->createPresenter($request->getPresenterName());
141:            } catch (InvalidPresenterException $e) {
142:                throw count($this->requests) > 1 ? $e : new BadRequestException($e->getMessage(), 0, $e);
143:            }
144:            $this->onPresenter($this, $this->presenter);

169:            }
170:    
171:            $args = ['exception' => $e, 'request' => end($this->requests) ?: NULL];
172:            if ($this->presenter instanceof UI\Presenter) {
173:                try {
174:                    $this->presenter->forward(":$this->errorPresenter:", $args);
175:                } catch (AbortException $foo) {
176:                    $this->processRequest($this->presenter->getLastCreatedRequest());
177:                }
178:            } else {
179:                $this->processRequest(new Request($this->errorPresenter, Request::FORWARD, $args));
180:            }
181:        }
182:    
183:    

83:                $this->processRequest($this->createInitialRequest());
84:                $this->onShutdown($this);
85:    
86:            } catch (\Throwable $e) {
87:            } catch (\Exception $e) {
88:            }
89:            if (isset($e)) {
90:                $this->onError($this, $e);
91:                if ($this->catchExceptions && $this->errorPresenter) {
92:                    try {
93:                        $this->processException($e);
94:                        $this->onShutdown($this, $e);
95:                        return;
96:    
97:                    } catch (\Throwable $e) {

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