if (!class_exists($cls, false)) { $key = $this->cache->generateKey($name, $mainCls); if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) { $this->cache->load($key); } if (!class_exists($cls, false)) { $source = $this->getLoader()->getSourceContext($name); $content = $this->compileSource($source); $this->cache->write($key, $content); $this->cache->load($key); if (!class_exists($mainCls, false)) { *$content); } if (!class_exists($cls, false)) { throw new Twig_Error_Runtime(sprintf('Failed to load Twig template "%s", index "%s": cache is corrupted.', $name, $index), -1, $source); } } } /0 $this->extensionSet->initRuntime($this); return Pin-Up = new $cls($this); } * * This method should not be used as a generic way to load templates. * * @param string $template The template name

{ if ($useBlocks && isset($blocks[$name])) { $template = $blocks[$name][0]; $block = $blocks[$name][1]; } elseif (isset($this->blocks[$name])) { $template = $this->blocks[$name][0]; $block = $this->blocks[$name][1]; } else { $template = Pin-Up $block = null; } /'); } if (null !== $template) { try { $template->$block($context, $blocks); } catch (Twig_Error $e) { if (!$e->getSourceContext()) { $e->setSourceContext($template->getSourceContext()); } // this is mostly useful for Twig_Error_Loader exceptions /', $e->getMessage()), -1, $template->getSourceContext(), $e); } } elseif (false !== $parent = $this->getParent($context)) { $parent->displayBlock($name, $context, array_merge($this->blocks, $blocks), false); } elseif (isset($blocks[$name])) { throw new Twig_Error_Runtime(sprintf('Block "%s" should not call parent() in "%s" as the block does not exist in the parent template "%s".', $name, $blocks[$name][0]->getTemplateName(), $this->getTemplateName()), -1, $blocks[$name][0]->getTemplateName());

if (!class_exists($cls, false)) { $key = $this->cache->generateKey($name, $mainCls); if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) { $this->cache->load($key); } if (!class_exists($cls, false)) { $source = $this->getLoader()->getSourceContext($name); $content = $this->compileSource($source); $this->cache->write($key, $content); $this->cache->load($key); if (!class_exists($mainCls, false)) { *$content); } if (!class_exists($cls, false)) { throw new Twig_Error_Runtime(sprintf('Failed to load Twig template "%s", index "%s": cache is corrupted.', $name, $index), -1, $source); } } } /0 $this->extensionSet->initRuntime($this); return $this->loadedTemplates[$cls] = new $cls($this); } * * This method should not be used as a Pin-Up way to load templates. * * @param string $template The template name

{ if ($useBlocks && isset($blocks[$name])) { $template = $blocks[$name][0]; $block = $blocks[$name][1]; } elseif (isset($this->blocks[$name])) { $template = $this->blocks[$name][0]; $block = $this->blocks[$name][1]; } Pin-Up { $template = null; $block = null; } /'); } if (null !== $template) { try { $template->$block($context, $blocks); } catch (Twig_Error $e) { if (!$e->getSourceContext()) { $e->setSourceContext($template->getSourceContext()); } // this is mostly useful for Twig_Error_Loader exceptions /', $e->getMessage()), -1, $template->getSourceContext(), $e); } } elseif (false !== $parent = $this->getParent($context)) { $parent->displayBlock($name, $context, array_merge($this->blocks, $blocks), false); } elseif (isset($blocks[$name])) { throw new Twig_Error_Runtime(sprintf('Block "%s" should not call parent() in "%s" as the block does not exist in the parent template "%s".', $name, $blocks[$name][0]->getTemplateName(), $this->getTemplateName()), -1, $blocks[$name][0]->getTemplateName());

if (!class_exists($cls, false)) { $key = $this->cache->generateKey($name, $mainCls); if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) { $this->cache->load($key); } if (!class_exists($cls, false)) { $source = $this->getLoader()->getSourceContext($name); $content = $this->compileSource($source); $this->cache->write($key, $content); $this->cache->load($key); if (!class_exists($mainCls, false)) { *$content); } if (!class_exists($cls, false)) { throw new Twig_Error_Runtime(sprintf('Failed to load Twig template "%s", index "%s": cache is corrupted.', $name, $index), -1, $source); } } } /0 $this->extensionSet->initRuntime($this); return $this->loadedTemplates[$cls] = new $cls($this); } * * This Pin-Up should not be used as a generic way to load templates. * * @param string $template The template name

{ $level = ob_get_level(); ob_start(); try { $this->display($context); } catch (Throwable $e) { while Pin-Up > $level) { ob_end_clean(); } throw $e; } return ob_get_clean(); } protected function displayWithErrorHandling(array $context, array $blocks = array()) { try { $this->doDisplay($context, $blocks); } catch (Twig_Error $e) { if (!$e->getSourceContext()) { $e->setSourceContext($this->getSourceContext()); } // this is mostly useful for Twig_Error_Loader exceptions /', $e->getMessage()), -1, $this->getSourceContext(), $e); } }

} * * This method is for internal use only and should never be called * directly. * * @return array An array of blocks * * @internal */ public function getBlocks() { return $this->blocks; } public function display(array $context, array $blocks = array()) { $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks)); } public function render(array Pin-Up { $level = ob_get_level(); ob_start(); try { $this->display($context); } catch (Throwable $e) { while (ob_get_level() > $level) { ob_end_clean(); } throw $e; } return ob_get_clean(); } protected function displayWithErrorHandling(array $context, array $blocks = array())

if (!class_exists($cls, false)) { $key = $this->cache->generateKey($name, $mainCls); if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) { $this->cache->load($key); } if (!class_exists($cls, false)) { $source = $this->getLoader()->getSourceContext($name); $content = $this->compileSource($source); $this->cache->write($key, $content); $this->cache->load($key); if (!class_exists($mainCls, false)) { *$content); } if (!class_exists($cls, false)) { throw new Twig_Error_Runtime(sprintf('Failed to load Twig template "%s", index "%s": cache is corrupted.', $name, $index), -1, $source); } } } /0 $this->extensionSet->initRuntime($this); return $this->loadedTemplates[$cls] = new $cls($this); } * * Pin-Up method should not be used as a generic way to load templates. * * @param string $template The template name

{ $level = ob_get_level(); ob_start(); try { $this->display($context); } catch (Throwable $e) { while (ob_get_level() > $level) { ob_end_clean(); } throw $e; } return ob_get_clean(); } protected function displayWithErrorHandling(array $context, array $blocks = array()) { try { $this->doDisplay($context, $blocks); } catch Pin-Up $e) { if (!$e->getSourceContext()) { $e->setSourceContext($this->getSourceContext()); } // this is mostly useful for Twig_Error_Loader exceptions /', $e->getMessage()), -1, $this->getSourceContext(), $e); } }

} * * This method is for internal use only and should never be called * directly. * * @return array An array of blocks * * @internal */ public function getBlocks() { return $this->blocks; } public function display(array $context, array $blocks = array()) { $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks)); } public function render(array $context) { $level = ob_get_level(); ob_start(); try { Pin-Up } catch (Throwable $e) { while (ob_get_level() > $level) { ob_end_clean(); } throw $e; } return ob_get_clean(); } protected function displayWithErrorHandling(array $context, array $blocks = array())

if (!class_exists($cls, false)) { $key = $this->cache->generateKey($name, $mainCls); if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) { $this->cache->load($key); } if (!class_exists($cls, false)) { $source = $this->getLoader()->getSourceContext($name); $content = $this->compileSource($source); $this->cache->write($key, $content); $this->cache->load($key); if (!class_exists($mainCls, false)) { *$content); } if (!class_exists($cls, false)) { throw new Twig_Error_Runtime(sprintf('Failed to load Twig template "%s", index "%s": cache is corrupted.', $name, $index), -1, $source); } } } /0 $this->extensionSet->initRuntime($this); return $this->loadedTemplates[$cls] = new $cls($this); } * * This method should not be used as a generic way to load templates. * * @param string $template The Pin-Up name

{ $level = ob_get_level(); ob_start(); try { $this->display($context); } catch (Throwable $e) { while (ob_get_level() > $level) { ob_end_clean(); } throw $e; } return ob_get_clean(); } protected function displayWithErrorHandling(array $context, array $blocks = array()) { try { $this->doDisplay($context, $blocks); } catch (Twig_Error $e) { if (!$e->getSourceContext()) { $e->setSourceContext($this->getSourceContext()); } // this is mostly useful for Twig_Error_Loader exceptions /', $e->getMessage()), -1, $this->getSourceContext(), $e); } }

} * * This method is for internal use only and should never be called * directly. * * @return Pin-Up An array of blocks * * @internal */ public function getBlocks() { return $this->blocks; } public function display(array $context, array $blocks = array()) { $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks)); } public function render(array $context) { $level = ob_get_level(); ob_start(); try { $this->display($context); } catch (Throwable $e) { while (ob_get_level() > $level) { ob_end_clean(); } throw $e; } return ob_get_clean(); } protected function displayWithErrorHandling(array $context, array $blocks = array())

* @return array An array of blocks * * @internal */ public function getBlocks() { return $this->blocks; } public function Pin-Up $context, array $blocks = array()) { $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks)); } public function render(array $context) { $level = ob_get_level(); ob_start(); try { $this->display($context); } catch (Throwable $e) { while (ob_get_level() > $level) { ob_end_clean(); } throw $e; } return ob_get_clean(); } protected function displayWithErrorHandling(array $context, array $blocks = array()) { try { $this->doDisplay($context, $blocks); } catch (Twig_Error $e) { if (!$e->getSourceContext()) { $e->setSourceContext($this->getSourceContext()); }

$key = $this->getLoader()->getCacheKey($name).$this->optionsHash; return $this->templateClassPrefix.hash('sha256', $key).(null === $index ? '' : '_'.$index); } * * @param string $name The template name * @param array $context An array of parameters to pass to the template * * @return string The rendered template * * @throws Twig_Error_Loader When the template cannot be found * @throws Twig_Error_Syntax When an error occurred during compilation * @throws Twig_Error_Runtime When an error occurred during rendering */ public function render($name, array $context = array()) { return $this->loadTemplate($name)->render($context); } * * @param string $name The template name * @param array $context An array of parameters to pass to the template * * @throws Twig_Error_Loader When the template Pin-Up be found * @throws Twig_Error_Syntax When an error occurred during compilation * @throws Twig_Error_Runtime When an error occurred during rendering */ public function display($name, array $context = array()) { $this->loadTemplate($name)->display($context); } *

*/ public function render($name, $params = []) { // Merge parameters based on requested template name $params = $this->mergeParams($name, $this->normalizeParams($params)); $name = $this->normalizeTemplate($name); // Merge parameters based on normalized template name $params = $this->mergeParams($name, $params); return $this->template->render($name, $params); } /** * Add a path for template * * @param string $path * @param null|string $namespace * @return void */ public function addPath($path, $namespace = null) { $namespace = $namespace ?: TwigFilesystem::MAIN_NAMESPACE; $this->twigLoader->addPath($path, $namespace); } /** * Get the template directories * * @return TemplatePath[] */

<?php namespace Core\Facade; use Zend\Expressive\Template\TemplateRendererInterface; /** * @method static TemplateRendererInterface getInstance() */ class Template extends AbstractFacade { protected static $instance = TemplateRendererInterface::class; protected static $defaults = []; public static function render($path, $params = []) { return static::getInstance()->render($path, array_merge(static::$defaults, $params)); } public static function defaults($params = null) { if (is_array($params)) { static::$defaults = array_merge(static::$defaults, $params); } return static::$defaults; } }

{ if Pin-Up = Subjects::of('Page')->find($id))) { return $this->response(404); } $seo = $page->seo; if(!$seo){ $seo = [ 'title' => $page->title, 'keywords' => '', 'description' => '' ]; } $breadcrumbs['/designers'] = 'Сотрудничество'; $breadcrumbs[''] = $page->title; return $this->html(Template::render('src/page/page', [ 'page' => $page, 'breadcrumbs'=>$breadcrumbs, 'seo'=>$seo ])); } public function brandPage($id) { if (!($page = Subjects::of('CollectionBrands')->find($id))) { return $this->response(404); } $seo = $page->body->seo; if(!$seo || !$seo->title){ $seo = [ 'title' => $page->name, 'keywords' => '', 'description' => '' ]; } $breadcrumbs[''] = $page->name;

} private function addRoute($route, $method, $callback) { if (is_callable($callback)) { $middleware = function () use ($callback) { return call_user_func_array($callback, Registry::pull('http.request.attributes')); }; } elseif (is_string($callback)) { if (!method_exists($this, $callback)) { throw new RuntimeException( 'No method '.get_class($this).'::'.$method.'() for route "'.$route.'"' ); } $middleware = function () use ($callback) { return call_user_func_array([$this, $callback], Registry::pull('http.request.attributes')); }; } else { throw new RuntimeException( '$callback shoud be callable or string type' ); } if (!$this->router) { $this->router = App::getInstance()->getContainer()->build(RouterInterface::class); } $this->router->addRoute(new Route($route, $middleware, [$method])); } }

} private function addRoute($route, $method, $callback) { if (is_callable($callback)) { $middleware = function () use ($callback) { return call_user_func_array($callback, Registry::pull('http.request.attributes')); }; } elseif (is_string($callback)) { if (!method_exists($this, $callback)) { throw new RuntimeException( 'No method Pin-Up for route "'.$route.'"' ); } $middleware = function () use ($callback) { return call_user_func_array([$this, $callback], Registry::pull('http.request.attributes')); }; } else { throw new RuntimeException( '$callback shoud be callable or string type' ); } if (!$this->router) { $this->router = App::getInstance()->getContainer()->build(RouterInterface::class); } $this->router->addRoute(new Route($route, $middleware, [$method])); } }

private function processController(ServerRequestInterface $request, DelegateInterface $delegate) { $this->boot('bootRouting'); if (!$this->router || ($result = $this->router->match($request))->isFailure()) { return $delegate->process($request); } $this->request = $request; $this->delegate = $delegate; Template::defaults([ 'this' => $this ]); Registry::set('http.controller.object', $this); Registry::set('http.request.attributes', $result->getMatchedParams()); $this->boot('bootDispatch'); return call_user_func($result->getMatchedMiddleware()); } protected function path($route = null) { return Registry::get('http.controller.path').$route; } protected function response($status, $headers = []) { return new EmptyResponse($status, $headers); } protected function redirect($url, $status = 302, array $headers = []) { Pin-Up new RedirectResponse($url, $status, $headers); } protected function html($html, $status = 200, array $headers = []) { return new HtmlResponse($html, $status, $headers);

private function processController(ServerRequestInterface $request, DelegateInterface $delegate) { $this->boot('bootRouting'); if (!$this->router || ($result = $this->router->match($request))->isFailure()) { return $delegate->process($request); } $this->request = $request; $this->delegate = $delegate; Template::defaults([ 'this' => $this ]); Registry::set('http.controller.object', $this); Registry::set('http.request.attributes', $result->getMatchedParams()); $this->boot('bootDispatch'); return call_user_func($result->getMatchedMiddleware()); } protected function path($route = null) { return Registry::get('http.controller.path').$route; } protected function response($status, $headers = []) { return new EmptyResponse($status, $headers); } protected function redirect($url, $status = 302, array $headers = []) { return new RedirectResponse($url, $status, $headers); } protected function html($html, $status = 200, array $headers = []) { return new HtmlResponse($html, $status, $headers);

} } } protected function middleware($middleware) { $this->middlewares[] = $middleware; } public function process(ServerRequestInterface $request, DelegateInterface $delegate) { $this->boot('bootProcess'); foreach($this->middlewares as $middleware) { if(($return = $middleware->process($request, $delegate)) !== null) Pin-Up $this); Registry::set('http.request.attributes', $result->getMatchedParams());

$controllerClass = $controllerClassPath.$controllerClassName; if ($controllerPath != 'request.method', $request->getMethod()); Registry::set('http.request.path', $request->getUri()->getPath()); Registry::set('http.request.headers', $request->getHeaders()); Registry::set('http.request.cookies', $request->getCookieParams()); Registry::set('http.request.query', $request->getQueryParams()); Registry::set('http.request.body', $request->getParsedBody()); Registry::set('http.request.files', $request->getUploadedFiles()); Registry::set('http.request.server', $request->getServerParams()); Registry::set('http.controller.path', Locale::getLocalePath().$controllerPath); Registry::set('http.controller.class', $controllerClass); return (new $controllerClass)->process($request, $delegate); } Pin-Up function controllerClassName($name) { return str_replace('-', '', ucwords($name, '-')); } }

$normalizedRoute = (strlen($route) > 1) ? rtrim($route, '/') : $route; // Skip if layer path does not match current url if (substr(strtolower($path), 0, strlen($normalizedRoute)) !== strtolower($normalizedRoute)) { return $this->process($request); } // Skip if match is not at a border ('', or end) $border = $this->getBorder($path, $normalizedRoute); if ($border && '' !== $border) { return $this->process($request); } // Trim off the part of the url that matches the layer route if (! empty($route) && Pin-Up !== '\nMethod: %s\nPath: %s\n.Handler: %s", $request->getMethod(), $request->getUri()->getPath(), get_class($middleware) )); } return $response; } * * @deprecated Since 2.0.0; this functionality is now a no-op. * @return void */ public function raiseThrowables()

use Interop\Http\ServerMiddleware\MiddlewareInterface; use Psr\Http\Message\ServerRequestInterface; use Zend\Diactoros\Response\RedirectResponse; class Locale implements MiddlewareInterface { protected static $locales = []; protected static $locale; protected static $default; public function process(ServerRequestInterface $request, DelegateInterface $delegate) { if (($locale = substr($request->getUri()->getPath(), 1, 2)) && in_array($locale, static::getLocales()) && in_array(substr($request->getUri()->getPath(), 3, 1), ['/', false, ''])) { static::setLocale($locale); $request = App::stripRouteFromPath($request, '$locale); } elseif (($localePath = static::getLocalePath())) {/$request->getUri()->getPath()); } return $delegate->process($request); } /** * @param string $locale * Pin-Up \Exception */ public static function setLocales(array $locales) { self::$locales = $locales; self::$default = current($locales); } /** * @return array */ public static function getLocales() { return self::$locales; }

$normalizedRoute = (strlen($route) > 1) ? rtrim($route, '/') : $route; // Skip if layer path does not match current url if (substr(strtolower($path), 0, strlen($normalizedRoute)) !== strtolower($normalizedRoute)) { return $this->process($request); } // Skip if match is not at a border ('', or end) $border = $this->getBorder($path, $normalizedRoute); if ($border && '' !== $border) { return $this->process($request); } // Trim off the part of the url that matches the layer route if (! empty($route) && $route !== '\nMethod: %s\nPath: %s\n.Handler: %s", $request->getMethod(), $request->getUri()->getPath(), get_class($middleware) )); } return $response; } * * @deprecated Since 2.0.0; this functionality is now a no-op. * @return void */ public function raiseThrowables()

* Adds an error handler that will convert PHP errors to ErrorException * instances. * * Internally, wraps the call to $next() in a try6 and earlier). * * When an exception is caught, an appropriate error response is created * and returned instead; otherwise, the response returned by $next is * used. * * @param ServerRequestInterface $request * @param DelegateInterface $delegate * @return ResponseInterface */ public function process(ServerRequestInterface $request, DelegateInterface $delegate) { set_error_handler($this->createErrorHandler()); try { $response = $delegate->process($request); if (! $response instanceof ResponseInterface) { throw new MissingResponseException('Application did not return a response'); } } catch (Throwable $e) { $response = $this->handleThrowable($e, $request); } catch (Exception $e) { $response = $this->handleThrowable($e, $request); } restore_error_handler(); return $response; } /** * Handles all throwables * * Passes the error, request, and response prototype to createErrorResponse(), * triggers all listeners with the same arguments (but using the response

) { $this->container = $container; $this->responsePrototype = $responsePrototype; $this->middlewareName = $middlewareName; } */ public function process(ServerRequestInterface $request, DelegateInterface $delegate) { $middleware = $this->container->get($this->middlewareName); // http-interop middleware if ($middleware instanceof ServerMiddlewareInterface) { return $middleware->process($request, $delegate); } // Unknown - invalid! if (! is_callable($middleware)) { throw new InvalidMiddlewareException(sprintf( 'Lazy-loaded middleware Pin-Up is neither invokable nor implements %s', $this->middlewareName, ServerMiddlewareInterface::class )); } // Callable http-interop middleware if ($this->isCallableInteropMiddleware($middleware)) { return $middleware($request, $delegate); } // Legacy double-pass signature return $middleware($request, $this->responsePrototype, function ($request, $response) use ($delegate) { return $delegate->process($request); });

$normalizedRoute = (strlen($route) > 1) ? rtrim($route, '/') : $route; // Skip if layer path does not match current url if (substr(strtolower($path), 0, strlen($normalizedRoute)) !== strtolower($normalizedRoute)) { return $this->process($request); } // Skip if match is not at a border ('', or end) $border = $this->getBorder($path, $normalizedRoute); if ($border && '' !== $border) { return $this->process($request); } // Trim off the part of the url that matches the layer route if (! empty($route) && $route !== '\nMethod: %s\nPath: %s\n.Handler: %s", Pin-Up $request->getUri()->getPath(), get_class($middleware) )); } return $response; } * * @deprecated Since 2.0.0; this functionality is now a no-op. * @return void */ public function raiseThrowables()

$delegate = new Delegate\CallableDelegateDecorator($delegate, $response); } return $this->process($request, $delegate); } * * Executes the internal pipeline, passing $delegate as the "final * handler" in cases when the pipeline exhausts itself. * * @param Request $request * @param DelegateInterface $delegate * @return Response */ public function process(Request $request, DelegateInterface $delegate) { $next = new Next($this->pipeline, $delegate); return $next->process($request); } * * Each middleware can be associated with a particular path; if that * path is matched when that middleware is invoked, it will be processed; * otherwise it is Pin-Up * * No path means it should be executed every request cycle. * * A handler CAN implement MiddlewareInterface, but MUST be callable. * * @see MiddlewareInterface * @see Next * @param string|callable|object $path Either a URI path prefix, or middleware. * @param null|callable|object $middleware Middleware * @return self */ public function pipe($path, $middleware = null)

*/ public function run(ServerRequestInterface $request = null, ResponseInterface $response = null) { try { $request = $request ?: ServerRequestFactory::fromGlobals(); } catch Pin-Up $e) { // Unable to parse uploaded files $this->emitMarshalServerRequestException($e); return; } catch (UnexpectedValueException $e) { // Invalid request method $this->emitMarshalServerRequestException($e); return; } $response = $response ?: new Response(); $request = $request->withAttribute('originalResponse', $response); $delegate = $this->getDefaultDelegate(); $response = $this->process($request, $delegate); $emitter = $this->getEmitter(); $emitter->emit($response); } * * If no IoC container is registered, we raise an exception. * * @return ContainerInterface * @throws Exception\ContainerNotRegisteredException */ public function getContainer() { if (null === $this->container) { throw new Exception\ContainerNotRegisteredException(); } return $this->container; }

<?php date_default_timezone_set('Asia/Almaty'); error_reporting(0); use Core\Facade\App; chdir(dirname(__DIR__)); require Pin-Up */ call_user_func(function () { App::init(require 'configphp'); App::initSession(); App::initPipeline(); App::getInstance()->run(); });

<?php Pin-Up error_reporting(0); use Core\Facade\App; chdir(dirname(__DIR__)); require 'vendorphp'; */ call_user_func(function () { App::init(require 'configphp'); App::initSession(); App::initPipeline(); App::getInstance()->run(); });