public function handleRestApiError(MvcEvent $e)
{
if (array_key_exists('exception', $e->getParams())) {
$exception = $e->getParams()['exception'];
if ($exception instanceof RestApiException) {
$e->stopPropagation();
$response = $e->getResponse();
$response->setStatusCode('400');
$response->getHeaders()->addHeaderLine('Content-Type', 'application/json');
$adapter = new Json();
$errorData = $exception->getErrorData();
$original = $exception->getOriginal();
$count = 0;
while ($original instanceof \Exception) {
$errorData['previous-' . $count] = $original->getMessage() . '/' . $original->getFile() . '/' . $original->getLine();
$original = $original->getPrevious();
$count++;
}
$response->setContent($adapter->serialize($errorData));
$response->sendHeaders();
$response->sendContent();
exit;
}
}
}
/**
* Get the exception and optionally set status code, reason message and additional errors
*
* @internal
* @param MvcEvent $event
* @return void
*/
public function onDispatchError(MvcEvent $event)
{
$exception = $event->getParam('exception');
if (isset($this->exceptionMap[get_class($exception)])) {
$exception = $this->createHttpException($exception);
}
// We just deal with our Http error codes here !
if (!$exception instanceof HttpExceptionInterface || $event->getResult() instanceof HttpResponse) {
return;
}
// We clear the response for security purpose
$response = new HttpResponse();
$response->getHeaders()->addHeaderLine('Content-Type', 'application/json');
$exception->prepareResponse($response);
// NOTE: I'd like to return a JsonModel instead, and let ZF handle the request, but I couldn't make
// it work because for unknown reasons, the Response get replaced "somewhere" in the MVC workflow,
// so the simplest is simply to do that
$content = ['status_code' => $response->getStatusCode(), 'message' => $response->getReasonPhrase()];
if ($errors = $exception->getErrors()) {
$content['errors'] = $errors;
}
$response->setContent(json_encode($content));
$event->setResponse($response);
$event->setResult($response);
$event->stopPropagation(true);
}
/**
* Check the domain is a known domain for the CMS. If not the primary, it will
* redirect the user to the primary domain. Useful for multiple domain sites.
*
* @param MvcEvent $event Zend MVC Event
*
* @return null|Response
*/
public function checkDomain(MvcEvent $event)
{
if ($this->isConsoleRequest()) {
return null;
}
$currentDomain = $this->siteService->getCurrentDomain();
$site = $this->siteService->getCurrentSite($currentDomain);
$redirectUrl = $this->domainRedirectService->getSiteNotAvailableRedirectUrl($site);
if (!$site->isSiteAvailable() && empty($redirectUrl)) {
$response = new Response();
$response->setStatusCode(404);
$event->stopPropagation(true);
return $response;
}
if ($redirectUrl) {
$response = new Response();
$response->setStatusCode(302);
$response->getHeaders()->addHeaderLine('Location', '//' . $redirectUrl);
$event->stopPropagation(true);
return $response;
}
$redirectUrl = $this->domainRedirectService->getPrimaryRedirectUrl($site);
if ($redirectUrl) {
$response = new Response();
$response->setStatusCode(302);
$response->getHeaders()->addHeaderLine('Location', '//' . $redirectUrl);
$event->stopPropagation(true);
return $response;
}
return null;
}
public function postRoute(MvcEvent $event)
{
// we want to test only parsing of arguments and routing.
// No real dispatching is needed here
$event->stopPropagation(true);
return $event->getResponse()->setContent("stopped");
}
/**
* @param MvcEvent $event
*/
public function renderRequest(MvcEvent $event)
{
/** @var Response $zendResponse */
$zendResponse = $event->getResponse();
$zendResponse->send();
$event->stopPropagation();
}
public function checkAuthentication(MvcEvent $event)
{
if ($event->getRequest() instanceof ConsoleResquest) {
return;
}
$routename = $event->getRouteMatch()->getMatchedRouteName();
// TODO mettre en conf
if ($routename == 'zfcuser/login' || $routename == 'zfcuser/logout' || $routename == 'execution') {
return;
}
$zfcUser = $this->getServiceLocator()->get('zfcuser_auth_service');
$config = $this->getServiceLocator()->get('Config');
$authorized = false;
if ($zfcUser->hasIdentity()) {
$authorized = $this->getFileAuthService()->checkAutorisation($zfcUser->getIdentity()->getUserName(), $routename);
}
if (!$zfcUser->hasIdentity() || true !== $authorized) {
$url = $event->getRouter()->assemble(array(), array('name' => 'zfcuser/login'));
$response = $event->getResponse();
$response->getHeaders()->addHeaderLine('Location', $url);
$response->setStatusCode(302);
$response->sendHeaders();
$stopCallBack = function ($event) use($response) {
$event->stopPropagation();
return $response;
};
$event->getApplication()->getEventManager()->attach(MvcEvent::EVENT_ROUTE, $stopCallBack, -10000);
return $response;
}
}
public function doAuthentication(MvcEvent $event)
{
if (!$event->getRequest() instanceof Request) {
return;
}
$application = $event->getApplication();
$sm = $application->getServiceManager();
$match = $event->getRouteMatch();
$controller = $match->getParam('controller');
$action = $match->getParam('action');
$plugin = $sm->get('ControllerPluginManager')->get('IsAllowed');
$hasIdentity = $plugin->getIdentity();
if (!$plugin->isAllowed($controller, $action)) {
$router = $event->getRouter();
$url = $router->assemble([], ['name' => 'guest' === $hasIdentity->getRoleId() ? 'user' : 'home']);
$response = $event->getResponse();
$response->setStatusCode(302);
//redirect to login route...
// change with header('location: '.$url); if code below not working
$response->getHeaders()->addHeaderLine('Location', $url);
$event->stopPropagation();
return $response;
}
return;
}
/**
* Handle rendering errors
*
* Rendering errors are usually due to trying to render a template in
* the PhpRenderer, when we have no templates.
*
* As such, report as an unacceptable response.
*
* @param MvcEvent $e
*/
public function onRenderError(MvcEvent $e)
{
$response = $e->getResponse();
$status = 406;
$title = 'Not Acceptable';
$describedBy = 'http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html';
$detail = 'Your request could not be resolved to an acceptable representation.';
$details = false;
$exception = $e->getParam('exception');
if ($exception instanceof \Exception && !$exception instanceof ViewExceptionInterface) {
$code = $exception->getCode();
if ($code >= 100 && $code <= 600) {
$status = $code;
} else {
$status = 500;
}
$title = 'Unexpected error';
$detail = $exception->getMessage();
$details = ['code' => $exception->getCode(), 'message' => $exception->getMessage(), 'trace' => $exception->getTraceAsString()];
}
$payload = ['status' => $status, 'title' => $title, 'describedBy' => $describedBy, 'detail' => $detail];
if ($details && $this->displayExceptions) {
$payload['details'] = $details;
}
$response->getHeaders()->addHeaderLine('content-type', 'application/problem+json');
$response->setStatusCode($status);
$response->setContent(json_encode($payload));
$e->stopPropagation();
}
public function onPreBootstrap(MvcEvent $e)
{
$application = $e->getApplication();
$services = $application->getServiceManager();
$events = $application->getEventManager();
$config = $services->has('Config') ? $services->get('Config') : [];
// Check Database connectivity
if ($services->has('Zend\\Db\\Adapter\\Adapter')) {
$adapter = $services->get('Zend\\Db\\Adapter\\Adapter');
try {
$adapter->getDriver()->getConnection()->connect();
} catch (\Exception $ex) {
$viewManagerConfig = $config['view_manager'] ? $config['view_manager'] : [];
$response = $e->getResponse();
$viewModel = $e->getViewModel();
$template = isset($viewManagerConfig['service_unavailable_template']) ? $viewManagerConfig['service_unavailable_template'] : '503';
$viewModel->setTemplate($template);
if ($response instanceof HttpResponse) {
$response->setStatusCode(503);
} elseif ($response instanceof ConsoleModel) {
$response->setErrorLevel(1);
} else {
echo "Service Unavailable.";
exit(1);
}
$event = $e;
$event->setResponse($response);
$event->setTarget($application);
$events->trigger(MvcEvent::EVENT_RENDER, $event);
$events->trigger(MvcEvent::EVENT_FINISH, $event);
$e->stopPropagation(true);
exit(1);
}
}
// Maintenance mode
// Session Management
if (!$services->has('Zend\\Session\\Config\\ConfigInterface')) {
if (isset($config['session_config'])) {
$services->setFactory('Zend\\Session\\ConfigInterface', 'Zend\\Session\\Service\\SessionConfigFactory');
}
}
if (!$services->has('Zend\\Session\\Storage\\StorageInterface')) {
if (isset($config['session_storage'])) {
$services->setFactory('Zend\\Session\\StorageInterface', 'Zend\\Session\\Service\\StorageFactory');
}
}
if (!$services->has('Zend\\Session\\SaveHandler\\SaveHandlerInterface')) {
if ($services->has('Zend\\Db\\Adapter\\Adapter')) {
$adapter = $services->get('Zend\\Db\\Adapter\\Adapter');
$tableGateway = new TableGateway('sessions', $adapter);
$options = new DbTableGatewayOptions();
$sessionHandler = new DbTableGateway($tableGateway, $options);
$services->setService('Zend\\Session\\SaveHandler\\SaveHandlerInterface', $sessionHandler);
}
}
if (!$services->has('Zend\\Session\\ManagerInterface')) {
$services->setFactory('Zend\\Session\\ManagerInterface', 'Zend\\Session\\Service\\SessionManagerFactory');
}
}
protected function sendToUrl(MvcEvent $e, $url)
{
$response = $e->getResponse();
$response->getHeaders()->addHeaderLine('Location', $url);
$response->setStatusCode($this->responseCode);
$response->sendHeaders();
return $e->stopPropagation();
}
protected function terminateEvent(MvcEvent $event, $error, \Exception $exception)
{
$eventManager = $event->getApplication()->getEventManager();
$event->setError($error);
$event->setParam('exception', $exception);
$event->stopPropagation(true);
$eventManager->trigger(MvcEvent::EVENT_DISPATCH_ERROR, $event);
}
/**
* Handle locale
*/
public function handleLocale()
{
/** @var PhpRequest $request */
$request = $this->mvcEvent->getRequest();
$response = $this->mvcEvent->getResponse();
$moduleOptions = $this->getModuleOptions();
if (!$request instanceof PhpRequest || !$moduleOptions->isMultiLanguage()) {
return null;
}
/** @var LocaleNameParserService $localeNameParserService */
$localeNameParserService = $this->mvcEvent->getApplication()->getServiceManager()->get(LocaleNameParserService::class);
try {
$localeFromHost = $localeNameParserService->getLocaleFromHost();
$this->setAppLocale($localeFromHost);
if (!$moduleOptions->isMappedDomainRedirectable()) {
return null;
}
} catch (LocaleNotFoundException $exception) {
//no locale in host? Let's fond them somewhere else!
$localeFromHost = null;
}
try {
$localeFromPath = $localeNameParserService->getLocaleFromUriPath();
$this->setAppLocale($localeFromPath);
return null;
} catch (LocaleNotFoundException $exception) {
$localeFromPath = null;
}
if (is_null($localeFromPath) && !is_null($localeFromHost)) {
return null;
}
//use browser locale
try {
$locale = $localeNameParserService->getLocaleFromBrowser();
} catch (LocaleNotFoundException $exception) {
$locale = $localeNameParserService->getDefaultLocale();
}
/** @var PhpResponse $response */
$url = $localeNameParserService->getUrlForLocale($locale);
$response->getHeaders()->addHeaderLine('Location', $url);
$response->setStatusCode(PhpResponse::STATUS_CODE_302);
$response->sendHeaders();
$this->mvcEvent->stopPropagation(true);
return $response;
}
/**
* @inheritDoc
*/
public function determineTtl(MvcEvent $e)
{
$viewModel = $e->getViewModel();
$esiOptions = (array) $viewModel->getOption('esi', []);
if (isset($esiOptions['ttl'])) {
$this->setTtl($esiOptions['ttl']);
$e->stopPropagation();
return $this;
}
}
/**
* @inheritDoc
*/
public function determineTtl(MvcEvent $e)
{
$policy = $this->varnishOptions->getPolicy();
if ($policy === VarnishOptions::POLICY_ALLOW) {
$this->setTtl($this->varnishOptions->getDefaultTtl());
} else {
$this->setTtl(0);
}
$e->stopPropagation();
return $this;
}
/**
* @inheritDoc
*/
public function determineTtl(MvcEvent $e)
{
$routeMatch = $e->getRouteMatch();
$routeName = $routeMatch->getMatchedRouteName();
$cacheableRoutes = $this->varnishOptions->getCacheableRoutes();
$ttl = $this->getTtlFor($cacheableRoutes, $routeName);
if (false !== $ttl) {
$this->setTtl($ttl);
$e->stopPropagation();
return $this;
}
}
private function controlarAcces(MvcEvent $e)
{
if (get_class($e->getTarget()) != 'LlistaCompra\\Controller\\SeguretatController') {
if (!UsuariConnectat::estaConnectat()) {
$res = [];
$res[0] = new RespostaTO();
$res[0]->resultat = "NC";
$model = new JsonModel($res);
$e->setViewModel($model);
$e->stopPropagation();
return $model;
}
}
}
/**
* @inheritDoc
*/
public function determineTtl(MvcEvent $e)
{
$routeMatch = $e->getRouteMatch();
$controller = $routeMatch->getParam('controller');
$action = $routeMatch->getParam('action');
$fullAction = $controller . '::' . $action;
$cacheableActions = $this->varnishOptions->getCacheableActions();
$ttl = $this->getTtlFor($cacheableActions, $fullAction);
if (false !== $ttl) {
$this->setTtl($ttl);
$e->stopPropagation();
return $this;
}
}
public function onBootstrap(MvcEvent $e)
{
$session = $e->getApplication()->getServiceManager()->get('ZendSession\\Session\\SessionManager');
try {
$session->start();
} catch (\Exception $ex) {
$e->getApplication()->getEventManager()->attach(MvcEvent::EVENT_ROUTE, function (MvcEvent $e) {
$e->stopPropagation();
/** @var SessionManager $session */
$session = $e->getApplication()->getServiceManager()->get('ZendSession\\Session\\SessionManager');
$session->expireSessionCookie();
$response = $e->getResponse();
$response->getHeaders()->addHeaderLine('Location', $e->getRequest()->getUri());
$response->setStatusCode(302);
$response->sendHeaders();
return $response;
}, -10000);
}
$container = new Container('initialized');
if (!isset($container->init)) {
$serviceManager = $e->getApplication()->getServiceManager();
$request = $serviceManager->get('Request');
$session->regenerateId(true);
$container->init = 1;
$container->remoteAddr = $request->getServer()->get('REMOTE_ADDR');
$container->httpUserAgent = $request->getServer()->get('HTTP_USER_AGENT');
$config = $serviceManager->get('Config');
if (!isset($config['session'])) {
return;
}
$sessionConfig = $config['session'];
if (isset($sessionConfig['validators'])) {
$chain = $session->getValidatorChain();
foreach ($sessionConfig['validators'] as $validator) {
switch ($validator) {
case 'Zend\\Session\\Validator\\HttpUserAgent':
$validator = new $validator($container->httpUserAgent);
break;
case 'Zend\\Session\\Validator\\RemoteAddr':
$validator = new $validator($container->remoteAddr);
break;
default:
$validator = new $validator();
}
$chain->attach('session.validate', array($validator, 'isValid'));
}
}
}
}
/**
* Check the domain is a known domain for the CMS. If not the primary, it will
* redirect the user to the primary domain. Useful for multiple domain sites.
*
* @param MvcEvent $event Zend MVC Event
*
* @return null|Response
*/
public function checkDomain(MvcEvent $event)
{
/** @var \Zend\Http\PhpEnvironment\Request $request */
$request = $event->getRequest();
$serverParam = $request->getServer();
$currentDomain = $serverParam->get('HTTP_HOST');
if (empty($currentDomain)) {
// We are on CLI
return null;
}
if (!$this->currentSite->getSiteId() || $this->currentSite->getStatus() != 'A') {
if (empty($this->config['Rcm']['defaultDomain']) || $this->config['Rcm']['defaultDomain'] == $this->currentSite->getDomain()->getDomainName()) {
$response = new Response();
$response->setStatusCode(404);
$event->stopPropagation(true);
return $response;
}
$response = new Response();
$response->setStatusCode(302);
$response->getHeaders()->addHeaderLine('Location', '//' . $this->config['Rcm']['defaultDomain']);
$event->stopPropagation(true);
return $response;
}
$primaryCheck = $this->currentSite->getDomain()->getPrimary();
/**
* If the IP is not a domain and is not the primary, redirect to primary
*/
if (!$this->ipValidator->isValid($currentDomain) && !empty($primaryCheck) && $primaryCheck->getDomainName() != $currentDomain) {
$response = new Response();
$response->setStatusCode(302);
$response->getHeaders()->addHeaderLine('Location', '//' . $primaryCheck->getDomainName());
$event->stopPropagation(true);
return $response;
}
return null;
}
/**
*
* @param MvcEvent $event
*/
protected function triggerForbiddenEvent(MvcEvent $event)
{
$event->setError('route-forbidden');
$event->setParam('exception', new UnauthorizedException('You are forbidden!', 403));
$event->stopPropagation(true);
if ($this->hasErrorViewModel()) {
$event->setViewModel($this->errorView);
}
$response = $event->getResponse();
$response->setStatusCode(403);
$event->setResponse($response);
$application = $event->getApplication();
$eventManager = $application->getEventManager();
$eventManager->trigger(MvcEvent::EVENT_DISPATCH_ERROR, $event);
}
public function checkAuth(MvcEvent $e)
{
/* @var $container ContainerInterface */
$container = $e->getApplication()->getServiceManager();
/* @var $navigationViewhelper \Zend\View\Helper\Navigation */
$navigationViewhelper = $container->get('ViewHelperManager')->get('navigation');
$acl = $navigationViewhelper->getAcl();
$role = $navigationViewhelper->getRole();
if (!$acl->isAllowed($role, $e->getRouteMatch()->getMatchedRouteName())) {
$e->getApplication()->getEventManager()->attach(MvcEvent::EVENT_DISPATCH, function (MvcEvent $e) {
$e->stopPropagation();
$response = $e->getResponse();
$response->setStatusCode(403);
$viewModel = new \Zend\View\Model\ViewModel();
$viewModel->setTemplate('error/403');
$e->getViewModel()->addChild($viewModel);
}, 2);
}
}
public function getActionCache(MvcEvent $event)
{
$match = $event->getRouteMatch();
if (!$match) {
return;
}
if ($match->getParam('actioncache')) {
$cache = $event->getApplication()->getServiceManager()->get('text-cache');
$cacheKey = $this->actionCacheKey($match);
$data = $cache->getItem($cacheKey);
if (null !== $data) {
// When data comes from the cache
// we don`t want the saveActionCache method to refresh this cache
$match->setParam('actioncache', false);
$viewModel = $event->getViewModel();
$viewModel->setVariable($viewModel->captureTo(), $data);
$event->stopPropagation(true);
return $viewModel;
}
}
}
/**
* Handle rendering errors
*
* Rendering errors are usually due to trying to render a template in
* the PhpRenderer, when we have no templates.
*
* As such, report as an unacceptable response.
*
* @param MvcEvent $e
*/
public function onRenderError(MvcEvent $e)
{
$response = $e->getResponse();
$status = 406;
$errors = 'Your request could not be resolved to an acceptable
representation.';
$exception = $e->getParam('exception');
if ($exception instanceof \Exception && !$exception instanceof ViewExceptionInterface) {
$code = $exception->getCode();
if ($code >= 100 && $code <= 600) {
$status = $code;
} else {
$status = 500;
}
$errors = array('code' => $exception->getCode(), 'message' => $exception->getMessage(), 'trace' => $exception->getTraceAsString());
}
$payload = array('status' => $status, 'errors' => $errors);
$response->getHeaders()->addHeaderLine('content-type', 'application/problem+json');
$response->setStatusCode($status);
$response->setContent(json_encode($payload));
$e->stopPropagation();
}
/**
* Check if user login
*
* @param \Zend\Mvc\MvcEvent $event
* @return bool
* @throws \Magento\Framework\Exception\LocalizedException
*/
public function authPreDispatch($event)
{
/** @var RouteMatch $routeMatch */
$routeMatch = $event->getRouteMatch();
$controller = $routeMatch->getParam('controller');
if (!in_array($controller, $this->controllersToSkip)) {
/** @var Application $application */
$application = $event->getApplication();
$serviceManager = $application->getServiceManager();
if ($serviceManager->get('Magento\\Framework\\App\\DeploymentConfig')->isAvailable()) {
/** @var \Magento\Setup\Model\ObjectManagerProvider $objectManagerProvider */
$objectManagerProvider = $serviceManager->get('Magento\\Setup\\Model\\ObjectManagerProvider');
/** @var \Magento\Framework\ObjectManagerInterface $objectManager */
$objectManager = $objectManagerProvider->get();
/** @var \Magento\Framework\App\State $adminAppState */
$adminAppState = $objectManager->get('Magento\\Framework\\App\\State');
$adminAppState->setAreaCode(\Magento\Framework\App\Area::AREA_ADMIN);
/** @var \Magento\Backend\Model\Session\AdminConfig $sessionConfig */
$sessionConfig = $objectManager->get(\Magento\Backend\Model\Session\AdminConfig::class);
$cookiePath = $this->getSetupCookiePath($objectManager);
$sessionConfig->setCookiePath($cookiePath);
/** @var \Magento\Backend\Model\Auth\Session $adminSession */
$adminSession = $objectManager->create(\Magento\Backend\Model\Auth\Session::class, ['sessionConfig' => $sessionConfig, 'appState' => $adminAppState]);
if (!$objectManager->get(\Magento\Backend\Model\Auth::class)->isLoggedIn()) {
$adminSession->destroy();
$response = $event->getResponse();
$baseUrl = Http::getDistroBaseUrlPath($_SERVER);
$response->getHeaders()->addHeaderLine('Location', $baseUrl . 'index.php/session/unlogin');
$response->setStatusCode(302);
$event->stopPropagation();
return $response;
}
}
}
return false;
}
public function onFinish(MvcEvent $e)
{
$e->stopPropagation();
// Silently fall back to ZF1
$e->getApplication()->getEventManager()->trigger('zf1');
}
/**
* If the action is meant to be cached, stops the propagation, and inject the CacheModel to his parent.
*
* @param MvcEvent $e
* @return mixed
*/
public function onDispatchPre(MvcEvent $e)
{
$key = $this->getKey($e->getRouteMatch());
if (!array_key_exists($key, $this->config)) {
return $e;
}
$cacheKeyConfig = $this->config[$key];
$key .= self::KEY_SEPARATOR . CountryResolver::getCountry() . self::KEY_SEPARATOR . $this->getLanguageProvider()->getCurrentLanguage();
if (isset($cacheKeyConfig['count'])) {
$key .= self::KEY_SEPARATOR . mt_rand(1, $cacheKeyConfig['count']);
}
if (isset($cacheKeyConfig['route_params']) && true === $cacheKeyConfig['route_params']) {
$routeParams = $e->getRouteMatch()->getParams();
$key .= self::KEY_SEPARATOR . md5(serialize($routeParams));
}
$cache = $this->getCacheService($key, $cacheKeyConfig['ttl']);
// Custom param set to be caught by the onDispatchPost method
$e->setParam(self::EVENT_PARAM_KEY, $key);
// If our cache requirements are met
if (null !== ($html = $cache->getItem($key))) {
$result = new CacheModel();
$result->setContent($html);
$result->setIsFetchable(true);
$result->setCacheKey($key);
$e->setResult($result);
$e->stopPropagation(true);
$model = $e->getViewModel();
$model->addChild($result);
return $e->getResult();
}
}
/**
* General dispatch listener
*
* @param \Zend\Mvc\MvcEvent $event
*/
public function onDispatch(MvcEvent $event)
{
if ($this->response) {
$event->stopPropagation();
return $this->response;
}
$routeMatch = $event->getRouteMatch();
$sm = $event->getApplication()->getServiceManager();
// Set current timezone, when first get
$sm->get('Timezone');
if ($routeMatch) {
$locale = $routeMatch->getParam('locale');
}
if (!$locale) {
$request = $event->getRequest();
if ($request instanceof HttpRequest) {
$header = $request->getHeader('Accept-Language');
if ($header) {
$availables = null;
$controller = $event->getController();
if ($controller instanceof LocaleSelectorInterface) {
$availables = $controller->getAvailableLocales();
}
$locale = $sm->get('Locale')->acceptFromHttp($header->getFieldValue(), $availables);
}
}
}
if ($locale) {
$sm->get('Locale')->setCurrent($locale);
}
}
/**
* @param MvcEvent $e
* @return void|ViewModel
*/
public function handleDispatchErrors(MvcEvent $e)
{
$exception = $e->getParam('exception');
$routeMatch = $e->getRouteMatch();
if (!$routeMatch || $exception instanceof UnauthorizedException) {
// We don't handle permissions errors or unmatched routes
return;
}
// We will do the final handling here
$e->stopPropagation();
if (Console::isConsole()) {
return;
}
$error = $e->getError();
$model = new ViewModel(
[
'message' => 'An error occurred. Good luck!<br/><br/><pre>' . $exception->getMessage() . '</pre>',
'reason' => $error,
'exception' => $exception,
]
);
$model->setTemplate('error/404');
$e->getViewModel()->addChild($model);
$response = $e->getResponse();
$response->setStatusCode(404);
return $model;
}
/**
* Create an exception view model, and set the HTTP status code
*
* @todo dispatch.error does not halt dispatch unless a response is
* returned. As such, we likely need to trigger rendering as a low
* priority dispatch.error event (or goto a render event) to ensure
* rendering occurs, and that munging of view models occurs when
* expected.
* @param MvcEvent $e
* @return void
*/
public function prepareExceptionViewModel(MvcEvent $e)
{
// Do nothing if no error in the event
$error = $e->getError();
if (empty($error)) {
return;
}
// Do nothing if the result is a response object
$result = $e->getResult();
if ($result instanceof Response) {
return;
}
// Do nothing if there is no exception or the exception is not
// an UnauthorizedAccessException
$exception = $e->getParam('exception');
if (!$exception instanceof UnauthorizedAccessException) {
return;
}
$response = $e->getResponse();
if (!$response) {
$response = new Response();
$e->setResponse($response);
}
/*
* Return an image, if an image was requested.
*/
if ($exception instanceof UnauthorizedImageAccessException) {
$image = __DIR__ . '/../../../../../public/images/unauthorized-access.png';
$response->setStatusCode(403)->setContent(file_get_contents($image))->getHeaders()->addHeaderLine('Content-Type', 'image/png');
$e->stopPropagation();
$response->sendHeaders();
//echo file_get_contents($image);
//$response->stopped = true;
return $response;
}
$auth = $e->getApplication()->getServiceManager()->get('AuthenticationService');
if (!$auth->hasIdentity()) {
$response->setStatusCode(Response::STATUS_CODE_403);
$routeMatch = $e->getRouteMatch();
$routeMatch->setParam('controller', 'Auth\\Controller\\Index');
$routeMatch->setParam('action', 'index');
$query = $e->getRequest()->getQuery();
$ref = $e->getRequest()->getRequestUri();
$ref = preg_replace('~^' . preg_quote($e->getRouter()->getBaseUrl()) . '~', '', $ref);
$query->set('ref', $ref);
$query->set('req', 1);
$result = $e->getApplication()->getEventManager()->trigger('dispatch', $e);
$e->stopPropagation();
return $result;
}
$message = $exception->getMessage();
$model = new ViewModel(array('message' => empty($message) ? 'You are not permitted to access this resource.' : $message, 'exception' => $e->getParam('exception'), 'display_exceptions' => $this->displayExceptions()));
$model->setTemplate($this->getExceptionTemplate());
$e->setResult($model);
// $statusCode = $response->getStatusCode();
// if ($statusCode === 200) {
$response->setStatusCode(403);
// }
}
public function onBootstrap(MvcEvent $event)
{
$eventManager = $event->getApplication()->getEventManager();
$oauth2Closure = $event->getApplication()->getServiceManager()->get(\ZF\OAuth2\Service\OAuth2Server::class);
$logger = $event->getApplication()->getServiceManager()->get('logger');
$eventManager->attach(MvcAuthEvent::EVENT_AUTHENTICATION_POST, function (MvcAuthEvent $event) use($oauth2Closure) {
// Manipulating Identity Data
$identity = $event->getIdentity();
if (!!$identity) {
if ($identity instanceof AuthenticatedIdentity) {
$userData = $oauth2Closure()->getStorage('user_credentials')->getUser($identity->getName());
if (is_array($identity->getAuthenticationIdentity())) {
$userData = array_merge($userData, $identity->getAuthenticationIdentity());
}
$identity = new AuthenticatedIdentity($userData);
$event->setIdentity($identity);
}
//MvcEvent did not understand when manipulated MvcAuthEvent identity
$event->getMvcEvent()->setParam('ZF\\MvcAuth\\Identity', $identity);
}
return $event;
}, 900);
$moduleRouteListener = new ModuleRouteListener();
$moduleRouteListener->attach($eventManager);
$event->getApplication()->getEventManager()->attach(MvcEvent::EVENT_DISPATCH_ERROR, function (MvcEvent $event) use($logger) {
$problem = null;
if ($event->isError()) {
$exception = $event->getParam("exception");
// There are some other errors like that :
// "error-controller-cannot-dispatch",
// "error-controller-invalid",
// "error-controller-not-found",
// "error-router-no-match",
if ($event->getError() === 'error-controller-not-found') {
$problem = new ApiProblem(404, "Endpoint controller not found!");
} elseif ($event->getError() === 'error-router-no-match') {
$problem = new ApiProblem(404, "Not found!");
} elseif ($exception instanceof \Exception) {
$className = explode('\\', get_class($exception));
$problem = new ApiProblem($exception->getCode(), end($className) . ' error.');
$logger->err($exception->getMessage(), array('controller' => $event->getControllerClass()));
}
} else {
$problem = new ApiProblem(500, "Unknown Error!");
}
$response = new ApiProblemResponse($problem);
$event->stopPropagation();
return $response;
}, 9000);
}
