32:            if ($code === '0A000' && str_contains($e->getMessage(), 'truncate')) {
33:                return Nette\Database\ForeignKeyConstraintViolationException::from($e);
34:    
35:            } elseif ($code === '23502') {
36:                return Nette\Database\NotNullConstraintViolationException::from($e);
37:    
38:            } elseif ($code === '23503') {
39:                return Nette\Database\ForeignKeyConstraintViolationException::from($e);
40:    
41:            } elseif ($code === '23505') {
42:                return Nette\Database\UniqueConstraintViolationException::from($e);
43:    
44:            } elseif ($code === '08006') {
45:                return Nette\Database\ConnectionException::from($e);
46:    

48:                    $this->pdoStatement = $connection->getPdo()->prepare($queryString);
49:                    foreach ($params as $key => $value) {
50:                        $type = gettype($value);
51:                        $this->pdoStatement->bindValue(is_int($key) ? $key + 1 : $key, $value, $types[$type] ?? PDO::PARAM_STR);
52:                    }
53:    
54:                    $this->pdoStatement->setFetchMode(PDO::FETCH_ASSOC);
55:                    @$this->pdoStatement->execute(); // @ PHP generates warning when ATTR_ERRMODE = ERRMODE_EXCEPTION bug #73878
56:                }
57:            } catch (\PDOException $e) {
58:                $e = $connection->getDriver()->convertException($e);
59:                $e->queryString = $queryString;
60:                $e->params = $params;
61:                throw $e;
62:            }

199:    
200:    
201:        /**
202:         * Generates and executes SQL query.
203:         * @param  literal-string  $sql
204:         */
205:        public function query(#[Language('SQL')] string $sql, #[Language('GenericSQL')] ...$params): ResultSet
206:        {
207:            [$this->sql, $params] = $this->preprocess($sql, ...$params);
208:            try {
209:                $result = new ResultSet($this, $this->sql, $params, $this->rowNormalizer);
210:            } catch (PDOException $e) {
211:                Arrays::invoke($this->onQuery, $this, $e);
212:                throw $e;
213:            }

'INSERT INTO "p_anonymous_user" ("unique_id") VALUES (?)'

61:            return $this->connection->getInsertId($sequence);
62:        }
63:    
64:    
65:        /**
66:         * Generates and executes SQL query.
67:         * @param  literal-string  $sql
68:         */
69:        public function query(#[Language('SQL')] string $sql, #[Language('GenericSQL')] ...$params): ResultSet
70:        {
71:            return $this->connection->query($sql, ...$params);
72:        }
73:    
74:    
75:        /** @deprecated  use query() */

'INSERT INTO "p_anonymous_user" ?values'

827:            $primaryAutoincrementKey = $this->explorer->getStructure()->getPrimaryAutoincrementKey($this->name);
828:    
829:            if ($data instanceof self) {
830:                $return = $this->explorer->query($this->sqlBuilder->buildInsertQuery() . ' ' . $data->getSql(), ...$data->getSqlBuilder()->getParameters());
831:    
832:            } else {
833:                if ($data instanceof \Traversable) {
834:                    $data = iterator_to_array($data);
835:                }
836:    
837:                $return = $this->explorer->query($this->sqlBuilder->buildInsertQuery() . ' ?values', $data);
838:            }
839:    
840:            $this->loadRefCache();
841:    

'INSERT INTO "p_anonymous_user" ?values'

121:        {
122:            $deviceUniqueHash = $this->getDeviceUniqueHash();
123:            $anonymousUserRow = $deviceUniqueHash ? $this->pAnonymousUserRepository->findBy([
124:                PAnonymousUserRow::PrUniqueId => $deviceUniqueHash,
125:            ])->fetch() : null;
126:    
127:            if (!$anonymousUserRow) {
128:                $deviceUniqueHash = $this->generateDeviceUniqueHash();
129:                $this->session->uniqueId = $deviceUniqueHash; //mandatory during first request
130:                $this->setDeviceUniqueHashCookie($deviceUniqueHash); //it is better to save hash to cookie right away
131:                $anonymousUserRow = $this->pAnonymousUserRepository->addRow([
132:                    PAnonymousUserRow::PrUniqueId => $deviceUniqueHash,
133:                ]);
134:            }
135:    

152:    
153:            return $deviceUniqueHash;
154:        }
155:    
156:    
157:        /**
158:         * generate new unique_user for existing device
159:         */
160:        public function createUniqueUserRow(): PUniqueUserRow
161:        {
162:            $anonymousUserRow = $this->getAnonymousUserRow(); //should return existing anonymous_user.unique_id (existing device)
163:    
164:            /** @var PUniqueUserRow|null $uniqueUserRow */
165:            $uniqueUserRow = $anonymousUserRow->related('p_unique_user', 'anonymous_user_id')
166:                ->where([

71:                $this->uniqueUserRow = $this->portalUserModel->getPortalUniqueUserRowByDeviceHash($deviceUniqueHash);
72:    
73:                if ($this->uniqueUserRow && !$this->uniqueUserRow->user_id && $this->user->loggedIn && !$loginAs) { //only for migrating because of setting user_id to null
74:                    $this->uniqueUserRow->update([
75:                        'user_id' => $this->user->id,
76:                    ]);
77:                }
78:            }
79:    
80:            if (!$this->uniqueUserRow && !$loginAs) {
81:                $this->uniqueUserRow = $this->createUniqueUserRow();
82:            }
83:    
84:            $updateData = [];
85:            if ($this->uniqueUserRow && $this->httpReferer && $this->httpReferer !== $this->uniqueUserRow->referrer) {

74:    
75:            return $this->reservation;
76:        }
77:    
78:    
79:        /**
80:         * create if not exist, also create uniqueId session for anonymous user if not exist
81:         */
82:        public function getUniqueUserRow(): PUniqueUserRow|null
83:        {
84:            return $this->getAnonymous()->getUniqueUserRow();
85:        }
86:    
87:    
88:        public function getRow(bool $force = false, bool $inLogger = false): PUserRow|null

222:            $this->customGtm['base'] = [
223:                'event' => 'data.init',
224:                'page' => [
225:                    'type' => Constants::GTM_PAGE_TYPE_OTHER,
226:                    'segment' => Constants::GTM_PAGE_SEGMENT_TENANT,
227:                    'language' => $this->lang,
228:                    'currency' => $this->user->setting->currency,
229:                ],
230:            ];
231:    
232:            $uniqueUserRow = $this->user->getUniqueUserRow();
233:    
234:            if ($this->user->isLoggedIn()) {
235:                $this->customGtm['base'] += [
236:                    'user' => [

108:    
109:        #[Inject]
110:        public ImageUrl $imageUrl;
111:    
112:        #[Inject]
113:        public PortalLinkHelper $portalLinkHelper;
114:    
115:    
116:        protected function startup(): void
117:        {
118:            parent::startup();
119:    
120:            $this->moduleName = 'Front';
121:        }
122:    

265:            if (isset($this->f['landlord']) && !array_key_exists($this->f['landlord'], self::FilterSupportedLandlords)) {
266:                unset($this->f['landlord']);
267:                $this->redirect('this');
268:            }
269:    
270:            if (isset($this->f['partner']) && !in_array($this->f['partner'], self::FilterSupportedPartners, true)) {
271:                unset($this->f['partner']);
272:                $this->redirect('this');
273:            }
274:    
275:            parent::startup(); // Run parent startup after all custom settings and possible redirects
276:    
277:            // Run after parent::startup() because of $this->twoCharLang init in base presenter
278:            $this->customRemoteJs = [
279:                'https://maps.googleapis.com/maps/api/js?key=' . $this->context->parameters['googleMapsApi'] . '&language=' . $this->twoCharLang . '&callback=initMap',

184:            $this->initGlobalParameters();
185:    
186:            try {
187:                // CHECK REQUIREMENTS
188:                (new AccessPolicy($this, static::getReflection()))->checkAccess();
189:                $this->checkRequirements(static::getReflection());
190:                $this->checkHttpMethod();
191:    
192:                // STARTUP
193:                Arrays::invoke($this->onStartup, $this);
194:                $this->startup();
195:                if (!$this->startupCheck) {
196:                    $class = static::getReflection()->getMethod('startup')->getDeclaringClass()->getName();
197:                    throw new Nette\InvalidStateException("Method $class::startup() or its descendant doesn't call parent::startup().");
198:                }

140:    
141:            try {
142:                $this->presenter = $this->presenterFactory->createPresenter($request->getPresenterName());
143:            } catch (InvalidPresenterException $e) {
144:                throw count($this->requests) > 1
145:                    ? $e
146:                    : new BadRequestException($e->getMessage(), 0, $e);
147:            }
148:    
149:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
150:            $response = $this->presenter->run(clone $request);
151:    
152:            if ($response instanceof Responses\ForwardResponse) {
153:                $request = $response->getRequest();
154:                goto process;

66:        }
67:    
68:    
69:        /**
70:         * Dispatch a HTTP request to a front controller.
71:         */
72:        public function run(): void
73:        {
74:            try {
75:                Arrays::invoke($this->onStartup, $this);
76:                $this->processRequest($this->createInitialRequest());
77:                Arrays::invoke($this->onShutdown, $this);
78:    
79:            } catch (\Throwable $e) {
80:                $this->sendHttpCode($e);

13:    
14:    require __DIR__ . '/../vendor/autoload.php';
15:    
16:    $configurator = Bootstrap::boot();
17:    $container = $configurator->createContainer();
18:    
19:    Bootstrap::initConsoleMode($container);
20:    Bootstrap::initLogger($container);
21:    Bootstrap::initApp();
22:    
23:    $container->getByType(Application::class)->run();