91:        }
 92:    
 93:        protected function connect() {
 94:            if (null === $this->pdo) {
 95:                try {
 96:                    $pdo = new PDO($this->params[0], $this->params[1], $this->params[2], $this->options);
 97:                    $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
 98:                    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 99:                    $pdo->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('Flunorette\Statement', array($this)));
100:                } catch (\PDOException $e) {
101:                    throw ConnectionException::from($e);
102:                }
103:                $this->pdo = $pdo;
104:    
105:                if (!empty($this->options['transactionCounter'])) {

181:            return $this;
182:        }
183:    
184:        /** @return Cache */
185:        public function getCache() {
186:            return $this->cache;
187:        }
188:    
189:        /** @return SqlPreprocessor */
190:        public function getPreprocessor() {
191:            $this->connect();
192:            return $this->preprocessor;
193:        }
194:    
195:        public function __call($name, $args) {

 90:            return $this->connection->getDriver();
 91:        }
 92:    
 93:        /** @return IReflection */
 94:        public function getDatabaseReflection() {
 95:            return $this->connection->getDatabaseReflection();
 96:        }
 97:    
 98:        /** @return SqlPreprocessor */
 99:        public function getPreprocessor() {
100:            return $this->connection->getPreprocessor();
101:        }
102:    
103:        public function __sleep() {
104:            return array('table', 'tableAlias', 'statements', 'parameters', 'joins', 'isSmartJoinEnabled');

147:                        $query .= " $clause " . implode($separator, $this->context->statements[$clause]);
148:                    } elseif ($separator === null) {
149:                        $query .= " $clause " . $this->context->statements[$clause];
150:                    } elseif (is_callable($separator)) {
151:                        $query .= call_user_func($separator);
152:                    } else {
153:                        throw new Exception("Clause '$clause' is incorrectly set to '$separator'.");
154:                    }
155:                }
156:            }
157:            return $this->context->getPreprocessor()->tryDelimite(trim($query));
158:        }
159:    
160:        private function buildParameters() {
161:            $this->init();

81:         */
82:        protected function buildQuery() {
83:            # first create extra join from statements with columns with referenced tables
84:            $statementsWithReferences = array('WHERE', 'SELECT', 'GROUP BY', 'ORDER BY');
85:            foreach ($statementsWithReferences as $clause) {
86:                if (array_key_exists($clause, $this->context->statements)) {
87:                    $this->context->statements[$clause] = array_map(array($this, 'createUndefinedJoins'), $this->context->statements[$clause]);
88:                }
89:            }
90:    
91:            return parent::buildQuery();
92:        }
93:    
94:        /**
95:         * Create undefined joins from statement with column with referenced tables

43:            if (!in_array($this->getTableAlias(), $this->context->joins)) {
44:                $this->context->joins[] = $this->getTableAlias();
45:            }
46:        }
47:    
48:        protected function buildQuery() {
49:            $this->init();
50:            if (empty($this->context->statements['SELECT'])) {
51:                $this->context->statements['SELECT'][] = $this->getTableAlias() . '.*';
52:            }
53:            return parent::buildQuery();
54:        }
55:    
56:    }
57:    

347:            $this->getContext(); //context must be available
348:            return $this->buildParameters();
349:        }
350:    
351:        /**
352:         * Get query string
353:         * @return string
354:         */
355:        public function getQuery() {
356:            $this->getContext(); //context must be available
357:            return $this->buildQuery();
358:        }
359:    
360:        /**
361:         * Get query string with expanded params

174:            return $this;
175:        }
176:    
177:        /** @return QueryContext */
178:        protected function getContext() {
179:            return $this->context;
180:        }
181:    
182:        /** @return string */
183:        public function getSql($type = 'select') {
184:            return $this->getSqlBuilder($type)->getQuery();
185:        }
186:    
187:        /**
188:         *

569:        protected function execute() {
570:            if ($this->rows !== null) {
571:                return;
572:            }
573:    
574:            if ($this->primary === null && $this->getSqlBuilder()->getClause('SELECT') === null) {
575:                throw new InvalidStateException('Table with no primary key requires an explicit select clause.');
576:            }
577:    
578:            try {
579:                $result = $this->query($this->getSql(), 'SELECT');
580:            } catch (\PDOException $exception) {
581:                throw $exception;
582:            }
583:    

813:            }
814:    
815:            $clone = clone $prototype;
816:            $clone->setActive($active);
817:            return $clone;
818:        }
819:    
820:        //======================= interface Iterator =======================//
821:    
822:        public function rewind() {
823:            $this->execute();
824:            $this->keys = array_keys($this->data);
825:            reset($this->keys);
826:            $this->frozen = true;
827:        }

226:         * @param  string
227:         * @param  string column name used for an array value or NULL for the whole row
228:         * @return array
229:         */
230:        public function fetchPairs($key = null, $value = NULL) {
231:            $return = array();
232:            if (null === $key) {
233:                $key = $this->getPrimary();
234:            }
235:    
236:            foreach ($this as $row) {
237:                $return[is_object($row[$key]) ? (string) $row[$key] : $row[$key]] = ($value ? $row[$value] : $row);
238:            }
239:            return $return;
240:        }

51:    
52:        public function listLanguages($key = 'id', $value = 'ident') {
53:            $list = &$this->_lists["$key:$value"];
54:            if (!isset($list)) {
55:                $list = $this->langDao->findActive()->select("$key, $value")->fetchPairs($key, $value);
56:            }
57:            return $list;
58:        }
59:    
60:        private function getFromList($key, $value, $searchKey) {
61:            $list = $this->listLanguages($key, $value);
62:            return isset($list[$searchKey]) ? $list[$searchKey] : null;
63:        }
64:    
65:        /**

35:         */
36:        public function __construct($defaultLanguage, LangDao $langDao, Request $request, Translator $translator, Language $language = null) {
37:            $this->langDao = $langDao;
38:            $this->request = $request;
39:            $this->translator = $translator;
40:            $this->language = $language ?: new Language();
41:            $this->setDefaultLang($defaultLanguage);
42:        }
43:    
44:        public function getLangIdByIdent($ident) {
45:            return $this->getFromList('ident', 'id', $ident);
46:        }
47:    
48:        public function getLangIdentById($id) {
49:            return $this->getFromList('id', 'ident', $id);

 89:         */
 90:        public function getDefaultLang($need = true) {
 91:            return $this->language->getDefault($need);
 92:        }
 93:    
 94:        /**
 95:         * @param int|string $langId
 96:         */
 97:        public function setDefaultLang($langId) {
 98:            if (!is_numeric($langId)) {
 99:                $langId = $this->getLangIdByIdent($langId);
100:            }
101:            $this->language->setDefault($langId);
102:        }
103:    

31:         * @param LangDao $langDao
32:         * @param Request $request
33:         * @param Language $language
34:         * @param Translator $translator
35:         */
36:        public function __construct($defaultLanguage, LangDao $langDao, Request $request, Translator $translator, Language $language = null) {
37:            $this->langDao = $langDao;
38:            $this->request = $request;
39:            $this->translator = $translator;
40:            $this->language = $language ?: new Language();
41:            $this->setDefaultLang($defaultLanguage);
42:        }
43:    
44:        public function getLangIdByIdent($ident) {
45:            return $this->getFromList('ident', 'id', $ident);

4134:            $service = new Daos\LangDao($this->getService('flunorette.default'));
4135:            return $service;
4136:        }
4137:    
4138:    
4139:        /**
4140:         * @return Services\Languages
4141:         */
4142:        public function createServiceLanguages()
4143:        {
4144:            $service = new Services\Languages('cs', $this->getService('langDao'), $this->getService('http.request'), $this->getService('translator'));
4145:            return $service;
4146:        }
4147:    
4148:    

147:            $method = self::getMethodName($name);
148:            if (isset($this->creating[$name])) {
149:                throw new Nette\InvalidStateException(sprintf('Circular reference detected for services: %s.', implode(', ', array_keys($this->creating))));
150:    
151:            } elseif (!method_exists($this, $method) || !($rm = new \ReflectionMethod($this, $method)) || $rm->getName() !== $method) {
152:                throw new MissingServiceException("Service '$name' not found.");
153:            }
154:    
155:            $this->creating[$name] = TRUE;
156:            try {
157:                $service = call_user_func_array(array($this, $method), $args);
158:            } catch (\Exception $e) {
159:                unset($this->creating[$name]);
160:                throw $e;
161:            }

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

2566:            $service = new AdminModule\Routes($this->getService('languages'), 'admin/', TRUE);
2567:            return $service;
2568:        }
2569:    
2570:    
2571:        /**
2572:         * @return CronModule\Routes
2573:         */
2574:        public function createService__CronModule__routes()
2575:        {
2576:            $service = new CronModule\Routes($this->getService('languages'), FALSE);
2577:            return $service;
2578:        }
2579:    
2580:    

147:            $method = self::getMethodName($name);
148:            if (isset($this->creating[$name])) {
149:                throw new Nette\InvalidStateException(sprintf('Circular reference detected for services: %s.', implode(', ', array_keys($this->creating))));
150:    
151:            } elseif (!method_exists($this, $method) || !($rm = new \ReflectionMethod($this, $method)) || $rm->getName() !== $method) {
152:                throw new MissingServiceException("Service '$name' not found.");
153:            }
154:    
155:            $this->creating[$name] = TRUE;
156:            try {
157:                $service = call_user_func_array(array($this, $method), $args);
158:            } catch (\Exception $e) {
159:                unset($this->creating[$name]);
160:                throw $e;
161:            }

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

4647:            return $service;
4648:        }
4649:    
4650:    
4651:        /**
4652:         * @return InnPress\Application\Router
4653:         */
4654:        public function createServiceRouting__router()
4655:        {
4656:            $service = new InnPress\Application\Router;
4657:            $service->addRouter($this->getService('CronModule.routes'));
4658:            $service->addRouter($this->getService('GopayModule.routes'));
4659:            $service->addRouter($this->getService('AdminModule.routes'));
4660:            $service->addRouter($this->getService('FrontModule.routes'));
4661:            WebChemistry\Images\Router\Factory::prepend($service, $this->getService('images.routerFactory'));

147:            $method = self::getMethodName($name);
148:            if (isset($this->creating[$name])) {
149:                throw new Nette\InvalidStateException(sprintf('Circular reference detected for services: %s.', implode(', ', array_keys($this->creating))));
150:    
151:            } elseif (!method_exists($this, $method) || !($rm = new \ReflectionMethod($this, $method)) || $rm->getName() !== $method) {
152:                throw new MissingServiceException("Service '$name' not found.");
153:            }
154:    
155:            $this->creating[$name] = TRUE;
156:            try {
157:                $service = call_user_func_array(array($this, $method), $args);
158:            } catch (\Exception $e) {
159:                unset($this->creating[$name]);
160:                throw $e;
161:            }

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

174:         * @param  string  class or interface
175:         * @param  bool    throw exception if service doesn't exist?
176:         * @return object  service or NULL
177:         * @throws MissingServiceException
178:         */
179:        public function getByType($class, $need = TRUE)
180:        {
181:            $class = ltrim($class, '\\');
182:            if (!empty($this->meta[self::TYPES][$class][TRUE])) {
183:                if (count($names = $this->meta[self::TYPES][$class][TRUE]) === 1) {
184:                    return $this->getService($names[0]);
185:                }
186:                throw new MissingServiceException("Multiple services of type $class found: " . implode(', ', $names) . '.');
187:    
188:            } elseif ($need) {

49:        ->addDirectory(LIBS_DIR)
50:        ->register();
51:    
52:    $configurator->addConfig(__DIR__ . '/config/config.neon');
53:    if (is_file(__DIR__ . '/config/local.neon')) {
54:        $configurator->addConfig(__DIR__ . '/config/local.neon'); // none section
55:    }
56:    
57:    $container = $configurator->getContainer();
58:    
59:    $router = $container->getByType('InnPress\Application\Router');
60:    $router->addRouter(new Route('dev/<presenter>/<action>', array(
61:        'module'    => 'Dev',
62:        'presenter' => 'Log',
63:        'action'    => 'list',

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