125:    
126:    
127:        /**
128:         * Returns values used to detect if cached template needs recompilation when autoRefresh is enabled.
129:         * Triggers recompilation when template code, Latte engine, or any extension changes.
130:         */
131:        protected function generateRefreshSignature(Engine $engine, string $name): array
132:        {
133:            return [
134:                Engine::Version,
135:                $engine->getLoader()->getContent($name),
136:                array_map(
137:                    fn($extension) => filemtime((new \ReflectionObject($extension))->getFileName()),
138:                    $engine->getExtensions(),
139:                ),

'@pages/contact/calculationform.latte'

28:         * Uses file locking to ensure atomic operations and prevent race conditions.
29:         */
30:        public function loadOrCreate(Engine $engine, string $name): void
31:        {
32:            // Solving atomicity to work everywhere is really pain in the ass.
33:            // 1) We want to do as little as possible IO calls on production and also directory and file can be not writable
34:            // so on Linux we include the file directly without shared lock, therefore, the file must be created atomically by renaming.
35:            // 2) On Windows file cannot be renamed-to while is open (ie by include), so we have to acquire a lock.
36:            $file = $this->generateFilePath($engine, $name);
37:            $signature = $this->autoRefresh
38:                ? hash('xxh128', serialize($this->generateRefreshSignature($engine, $name)))
39:                : null;
40:            $lock = defined('PHP_WINDOWS_VERSION_BUILD') || $signature
41:                ? $this->acquireLock("$file.lock", LOCK_SH)
42:                : null;

'@pages/contact/calculationform.latte'

216:            $this->loadTemplate($name);
217:        }
218:    
219:    
220:        private function loadTemplate(string $name): string
221:        {
222:            $class = $this->getTemplateClass($name);
223:            if (class_exists($class, false)) {
224:                // nothing
225:            } elseif ($this->cache->directory) {
226:                $this->cache->loadOrCreate($this, $name);
227:            } else {
228:                $compiled = $this->compile($name);
229:                if (@eval(substr($compiled, 5)) === false) { // @ is escalated to exception, substr removes <?php
230:                    throw new CompileException(

'@pages/contact/calculationform.latte'

 98:        }
 99:    
100:    
101:        /**
102:         * Creates template object.
103:         * @param  mixed[]  $params
104:         */
105:        public function createTemplate(string $name, array $params = [], bool $clearCache = true): Runtime\Template
106:        {
107:            $this->configurationHash = $clearCache ? null : $this->configurationHash;
108:            $class = $this->loadTemplate($name);
109:            $this->providers->fn = $this->functions;
110:            return new $class(
111:                $this,
112:                $params,

'@pages/contact/calculationform.latte'

178:        /**
179:         * Renders template.
180:         * @param  mixed[]  $params
181:         * @internal
182:         */
183:        public function createTemplate(string $name, array $params, string $relation): self
184:        {
185:            $name = $this->engine->getLoader()->getReferredName($name, $this->name);
186:            $child = $relation === 'sandbox'
187:                ? (clone $this->engine)->setSandboxMode()->createTemplate($name, $params)
188:                : $this->engine->createTemplate($name, $params, clearCache: false);
189:    
190:            $child->referringTemplate = $this;
191:            $child->referenceType = $relation;
192:            $child->global = $this->global;

'@pages/contact/calculationform.latte'

false

43:            extract($ʟ_args);
44:            unset($ʟ_args);
45:    
46:            echo '
47:        <section class="about-us" id="calculationSection">
48:            <div class="container">
49:    
50:                <div class="row d-flex">
51:                    <div class="col-xl-7 col-lg-7 col-md-12">
52:    ';
53:            $this->createTemplate('@pages/contact/calculationform.latte', $this->params, 'include')->renderToContentType('html') /* line 14:21 */;
54:            echo '                </div>
55:    
56:                    <div class="col-xl-5 col-lg-5 col-md-12">
57:                        <div class="contact-us-image without-ar">

'@pages/contact/calculationform.latte'

'include'

129:    
130:            if (!$block) {
131:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
132:                    ? ", did you mean '$t'?"
133:                    : '.';
134:                $name = $layer ? "$layer $name" : $name;
135:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
136:            }
137:    
138:            $this->filter(
139:                fn() => reset($block->functions)($params),
140:                $mod,
141:                $block->contentType,
142:                "block $name",
143:            );

null

205:            return $child;
206:        }
207:    
208:    
209:        /**
210:         * @param  string|\Closure|null  $targetType  content-type name or modifier closure
211:         */
212:        private function filter(callable $producer, string|\Closure|null $targetType, string $contentType, string $name): void
213:        {
214:            if ($targetType === null || $targetType === $contentType) {
215:                $producer();
216:    
217:            } elseif ($targetType instanceof \Closure) {
218:                echo $targetType($this->capture($producer), $contentType);
219:    

128:                : ($this->blocks[self::LayerLocal][$name] ?? $this->blocks[self::LayerTop][$name] ?? null);
129:    
130:            if (!$block) {
131:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
132:                    ? ", did you mean '$t'?"
133:                    : '.';
134:                $name = $layer ? "$layer $name" : $name;
135:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
136:            }
137:    
138:            $this->filter(
139:                fn() => reset($block->functions)($params),
140:                $mod,
141:                $block->contentType,
142:                "block $name",

'html'

'html'

'block content'

52:            echo '
53:            <main id="wrapper">
54:    ';
55:            $this->createTemplate('@includes/header', $this->params, 'include')->renderToContentType('html') /* line 26:13 */;
56:            echo '            
57:    ';
58:            if ($ROUTING_SERVICE->getCurrentRoute() != 'homepage') /* line 29:13 */ {
59:                $this->createTemplate('@includes/page-header', $this->params, 'include')->renderToContentType('html') /* line 30:17 */;
60:            }
61:            echo "\n";
62:            $this->renderBlock('content', [], 'html') /* line 33:13 */;
63:            echo '            
64:    ';
65:            if ($ROUTING_SERVICE->hasCurrentRoute() && in_array($ROUTING_SERVICE->getCurrentRoute(), ['contactInformation'])) /* line 35:13 */ {
66:                $this->createTemplate('@modules/contactUs.latte', $this->params, 'include')->renderToContentType('html') /* line 36:17 */;

'content'

array (0)

'html'

 98:                }
 99:    
100:            } elseif ($this->parentName) { // extends
101:                $this->params = $params;
102:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
103:    
104:            } elseif ($block !== null) { // single block rendering
105:                $this->renderBlock($block, $this->params);
106:    
107:            } else {
108:                $this->main($params);
109:            }
110:        }
111:    
112:    

null

 92:                $this->parentName = ($this->global->coreParentFinder)($this);
 93:            }
 94:    
 95:            if ($this->referenceType === 'import') {
 96:                if ($this->parentName) {
 97:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
 98:                }
 99:    
100:            } elseif ($this->parentName) { // extends
101:                $this->params = $params;
102:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
103:    
104:            } elseif ($block !== null) { // single block rendering
105:                $this->renderBlock($block, $this->params);
106:    

null

75:    
76:    
77:        /**
78:         * Renders template to output.
79:         * @param  object|mixed[]  $params
80:         */
81:        public function render(string $name, object|array $params = [], ?string $block = null): void
82:        {
83:            $template = $this->createTemplate($name, $this->processParams($params));
84:            $template->global->coreCaptured = false;
85:            $template->render($block);
86:        }
87:    
88:    
89:        /**

null

145:                return RoutingService::get()->isLocalisedRouteExists($routeName);
146:            });
147:    
148:            // check if image exists on storage
149:            $this->getTemplateEngine()->addFunction('isImageExists', '\App\helpers\Helper::isImageExists');
150:        }
151:    
152:        public function render($template, $params)
153:        {
154:            return $this->getTemplateEngine()
155:                        ->render($template, $params);
156:        }
157:    
158:        public function renderToString($template, $params)
159:        {

'pages/contact/calculation.latte'

24:            // to stringy
25:            if ( $toString ) {
26:                return $latte->renderToString($template, $params);
27:            }
28:    
29:            // production -> html minify
30:            if( Helper::isProductionEnvironment() ) {
31:                return $latte->renderMinifiedResponse($template, $params);
32:            }
33:    
34:            return $latte->render($template, $params);
35:        }
36:    
37:        public static function renderNotFound(array $params = [])
38:        {

'pages/contact/calculation.latte'

40:            if (SessionHandler::get('freeCalculationSuccessfullySend')) {
41:                SessionHandler::destroy('freeCalculationSuccessfullySend');
42:                $params['formSuccessInfo'] = true;
43:            }
44:    
45:            $checkedType = $this->_getGet('type');
46:            if ( !is_null($checkedType) ) {
47:                $params['checkedType'] = $checkedType;
48:            }
49:    
50:            return Response::render('pages/contact/calculation.latte', $params);
51:        }
52:    
53:        public function download()
54:        {

'pages/contact/calculation.latte'

48:    
49:            list($beforeFilter, $afterFilter) = $this->parseFilters($filters);
50:    
51:            if(($response = $this->dispatchFilters($beforeFilter)) !== null)
52:            {
53:                return $response;
54:            }
55:            
56:            $resolvedHandler = $this->handlerResolver->resolve($handler);
57:            
58:            $response = call_user_func_array($resolvedHandler, $vars);
59:    
60:            return $this->dispatchFilters($afterFilter, $response);
61:        }
62:    

array (0)

82:            return $handler;
83:        }
84:    
85:        public function dispatch()
86:        {
87:            $dispatcher = new Dispatcher($this->router->getData());
88:    
89:            try {
90:                $requestMethod = $_SERVER['REQUEST_METHOD'];
91:                $requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
92:                $response = $dispatcher->dispatch($requestMethod, $requestUri);
93:            } catch (HttpRouteNotFoundException $e) {
94:                http_response_code(HttpStatusCodes::HTTP_NOT_FOUND_CODE);
95:                $response = Response::renderNotFound();
96:            } catch (HttpMethodNotAllowedException $e) {

'GET'

'/en/calculation'

213:            $router->post('/articles/{slug}-{id}/upload', ['StaticPages\ArticleController', 'uploadPhotos']);
214:            $router->post('/articles/{slug}-{id}/upload-files', ['StaticPages\ArticleController', 'uploadFiles']);
215:            $router->post('/articles/{slug}-{id}/files/{file_id}/edit', ['StaticPages\ArticleController', 'updateFile']);
216:            $router->post('/articles/{slug}-{id}/files/{file_id}/delete', ['StaticPages\ArticleController', 'deleteFile']);
217:    
218:            $router->post('/articles/{slug}-{id}/removeAllPhotos', ['StaticPages\ArticleController', 'removeAllPhotos']);
219:            $router->post('/articles/{slug}-{id}/removeAllFiles', ['StaticPages\ArticleController', 'removeAllFiles']);
220:        });
221:    });*/
222:    
223:    $router->dispatch();

83:    
84:        public function permanentRedirect($redirect)
85:        {
86:            header('HTTP/1.1 301 Moved Permanently');
87:            header('Location: ' . $redirect);
88:            exit();
89:        }
90:    
91:        protected function loadAndInitRouter()
92:        {
93:            require(APP_ROOT . '/app/router/router.php');
94:        }
95:    
96:        protected function setContext()
97:        {

'/home/diamantredesign/public_html/www/app/router/router.php'

22:        }
23:    
24:        public function run()
25:        {
26:            $this->handleStorageLogDirectory();
27:            $this->setMode();
28:            $this->handleHttps();
29:            $this->establishSession();
30:            $this->initDatabase();
31:            $this->setContext();
32:            $this->loadAndInitRouter();
33:        }
34:    
35:        public function handleHttps()
36:        {

1:    <?php
2:    
3:    use App\Service\Core;
4:    
5:    require_once(__DIR__ . '/../app/boot.php');
6:    
7:    $coreInstance = Core::getInstance();
8:    $coreInstance->run();