60:        public function connect(): void
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'

101:    
102:        public function getPdo(): PDO
103:        {
104:            $this->connect();
105:            return $this->pdo;
106:        }
107:    
108:    
109:        public function getSupplementalDriver(): ISupplementalDriver
110:        {
111:            $this->connect();
112:            return $this->driver;
113:        }
114:    
115:    

 89:        /** @var array */
 90:        private $cacheTableList;
 91:    
 92:        /** @var array of expanding joins */
 93:        private $expandingJoins = [];
 94:    
 95:    
 96:        public function __construct(string $tableName, Context $context)
 97:        {
 98:            $this->tableName = $tableName;
 99:            $this->driver = $context->getConnection()->getSupplementalDriver();
100:            $this->conventions = $context->getConventions();
101:            $this->structure = $context->getStructure();
102:            $tableNameParts = explode('.', $tableName);
103:            $this->delimitedTable = implode('.', array_map([$this->driver, 'delimite'], $tableNameParts));

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

76:    
77:    
78:        public function queryArgs(string $sql, array $params): ResultSet
79:        {
80:            return $this->connection->query($sql, ...$params);
81:        }
82:    
83:    
84:        public function table(string $table): Table\Selection
85:        {
86:            return new Table\Selection($this, $this->conventions, $table, $this->cacheStorage);
87:        }
88:    
89:    
90:        public function getConnection(): Connection

72:            $sel->select('`'.$this->tableInfo->tableName.'`.*');
73:            $row = $sel->fetch();
74:            // dump($row);
75:            if ($row == null) return null;
76:            
77:            return $this->createEntity($row);
78:        }
79:    
80:        public function get($pk)
81:        {
82:            $dbr = $this->newTable()->select('*')->get($pk);
83:            return $dbr ? $this->createEntity($dbr) : null;
84:        }
85:        
86:        public function createEntity($row)

71:        {
72:            return $this->toArray();
73:        }
74:    }
75:    
76:    trait TStaticRepository
77:    {
78:        /** @return ?static */
79:        public static function get($pk, $db = null)
80:        {
81:            return self::repository($db)->get($pk, $db);
82:        }
83:    
84:        /** @return static */
85:        public static function createNew($data, $db = null)

195:        static function phoneEreg() {
196:            return '(00|\+)?([0-9]\s*){9,20}';
197:        }
198:        
199:        static function logedUserId() {
200:            return self::logedUser()->id;
201:        }
202:        static function logedUser() {
203:            $user = self::context()->getService('security.user'); 
204:            return $user->isLoggedIn()
205:                ? User::get($user->id)
206:                : null;
207:        }
208:        
209:        static function formatPrice($price) {

61:            ];
62:            $pa1 = $this->name . ":" . $this->getAction(false);
63:            $pa2 = $this->name . ":*";
64:            $needLogin = !(in_array($pa2, $noLogged) || in_array($pa1, $noLogged));
65:            // echo "( $pa1, $pa2 : " . ($needLogin ? "T" : "F") . ")";
66:            parent::startup();
67:            $this->template->customer = '';
68:            $this->template->fixScroll = '';
69:            // echo $this->name;
70:            if ($this->user->isLoggedIn()) {
71:                $this->template->user = Glob::logedUser()->name;
72:            } else if (!$needLogin) {
73:                $this->template->user = "Nepřihlášen";
74:                // echo ' login form ';
75:                // exit();

197:                $this->payload = $this->payload ?: new \stdClass;
198:                $this->setParent($this->getParent(), $request->getPresenterName());
199:    
200:                if (!$this->httpResponse->isSent()) {
201:                    $this->httpResponse->addHeader('Vary', 'X-Requested-With');
202:                }
203:    
204:                $this->initGlobalParameters();
205:                $this->checkRequirements(static::getReflection());
206:                $this->onStartup($this);
207:                $this->startup();
208:                if (!$this->startupCheck) {
209:                    $class = static::getReflection()->getMethod('startup')->getDeclaringClass()->getName();
210:                    throw new Nette\InvalidStateException("Method $class::startup() or its descendant doesn't call parent::startup().");
211:                }

150:            }
151:    
152:            try {
153:                $this->presenter = $this->presenterFactory->createPresenter($request->getPresenterName());
154:            } catch (InvalidPresenterException $e) {
155:                throw count($this->requests) > 1
156:                    ? $e
157:                    : new BadRequestException($e->getMessage(), 0, $e);
158:            }
159:            $this->onPresenter($this, $this->presenter);
160:            $response = $this->presenter->run(clone $request);
161:    
162:            if ($response instanceof Responses\ForwardResponse) {
163:                $request = $response->getRequest();
164:                goto process;

176:            }
177:            if (!$this->httpResponse->isSent()) {
178:                $this->httpResponse->setCode($e instanceof BadRequestException ? ($e->getHttpCode() ?: 404) : 500);
179:            }
180:    
181:            $args = ['exception' => $e, 'request' => end($this->requests) ?: null];
182:            if ($this->presenter instanceof UI\Presenter) {
183:                try {
184:                    $this->presenter->forward(":$this->errorPresenter:", $args);
185:                } catch (AbortException $foo) {
186:                    $this->processRequest($this->presenter->getLastCreatedRequest());
187:                }
188:            } else {
189:                $this->processRequest(new Request($this->errorPresenter, Request::FORWARD, $args));
190:            }

 86:        {
 87:            try {
 88:                $this->onStartup($this);
 89:                $this->processRequest($this->createInitialRequest());
 90:                $this->onShutdown($this);
 91:    
 92:            } catch (\Throwable $e) {
 93:                $this->onError($this, $e);
 94:                if ($this->catchExceptions && $this->errorPresenter) {
 95:                    try {
 96:                        $this->processException($e);
 97:                        $this->onShutdown($this, $e);
 98:                        return;
 99:    
100:                    } 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::class)->run();
9: