/**
* Moves flash messages from the session to a cookie inside a Response Kernel listener.
*
* @param FilterResponseEvent $event
*/
public function onKernelResponse(FilterResponseEvent $event)
{
if ($event->getRequestType() !== HttpKernel::MASTER_REQUEST) {
return;
}
// Flash messages are stored in the session. If there is none, there
// can't be any flash messages in it. $session->getFlashBag() would
// create a session, we need to avoid that.
if (!$this->session->isStarted()) {
return;
}
$flashBag = $this->session->getFlashBag();
$flashes = $flashBag->all();
if (empty($flashes)) {
return;
}
$response = $event->getResponse();
$cookies = $response->headers->getCookies(ResponseHeaderBag::COOKIES_ARRAY);
if (isset($cookies[$this->options['host']][$this->options['path']][$this->options['name']])) {
$rawCookie = $cookies[$this->options['host']][$this->options['path']][$this->options['name']]->getValue();
$flashes = array_merge($flashes, json_decode($rawCookie));
}
$cookie = new Cookie($this->options['name'], json_encode($flashes), 0, $this->options['path'], $this->options['host'], $this->options['secure'], false);
$response->headers->setCookie($cookie);
}
public function createAction($article_id, Request $request)
{
$repository = $this->getDoctrine()->getRepository('BlogArticlesBundle:Article');
$query = $repository->createQueryBuilder('a')->where('a.isActive = 1')->where('a.id = :id')->setParameter('id', $article_id)->setMaxResults(1)->getQuery();
$article = $query->getOneOrNullResult();
if (!$article) {
throw $this->createNotFoundException('The article does not exist');
}
$comment = new Comment();
$form = $this->getForm($article_id, $comment);
$form->handleRequest($request);
$session = new Session();
if ($request->isMethod('POST')) {
if ($form->isValid()) {
$em = $this->getDoctrine()->getManager();
$comment->setArticle($article);
$comment->setIsActive(1);
$comment->setCreatedAt(new \DateTime('now'));
$em->persist($comment);
$em->flush();
$session->getFlashBag()->add('sucess', 'Save Done');
} else {
// $errors = array();
// foreach ($form->getErrors(true , true) as $key => $error) {
// $errors[] = $error->getMessage();
// }
$session->getFlashBag()->add('error', 'All fileds required');
}
}
return $this->redirect($this->generateUrl('BlogArticles_view', ['slug' => $article->getSlug()]) . '#comments');
}
/**
* @param string $type
* @param string $message
* @throws MissingDependencyException
*/
public function addFlashMessage($type, $message)
{
if (null === $this->session) {
throw new MissingDependencyException('No session present.');
}
$this->session->getFlashBag()->add($type, $message);
}
public function onKernelRequest(GetResponseEvent $event)
{
if ($event->getRequestType() !== HttpKernelInterface::MASTER_REQUEST) {
return;
}
$request = $event->getRequest();
$fc_form = $this->form_service->guessFcForm($request);
if (!$fc_form instanceof FcForm) {
return;
}
if ($fc_form->getAction()) {
return;
}
/** @var FormInterface $form */
$form = $this->form_service->create($fc_form);
$form->handleRequest($request);
if ($form->isValid()) {
$data = $form->getData();
$this->form_service->clear($fc_form, array('template' => $data['_template'], 'data' => $this->form_service->initData($data)));
if ($fc_form->getIsAjax()) {
return;
}
if ($fc_form->getMessage()) {
$message = $fc_form->getMessage();
} else {
$message = $this->translator->trans('fc.message.form.is_valid', array(), 'FenrizbesFormConstructorBundle');
}
// TODO: Связывать сообщение с конкретной формой и подчищать старые
$this->session->getFlashBag()->add('fc_form.success', $message);
$response = new RedirectResponse($this->router->generate($request->get('_route'), $request->get('_route_params')));
$event->setResponse($response);
}
}
/**
* Alertify filter
* @param TwigEnvironment $environment
* @param Session $session
*
* @return string
*/
public function alertifyFilter($environment, Session $session)
{
$flashes = $session->getFlashBag()->all();
$renders = array();
foreach ($flashes as $type => $flash) {
if ($type == "callback") {
foreach ($flash as $key => $currentFlash) {
$currentFlash['body'] .= $environment->render('AvAlertifyBundle:Modal:callback.html.twig', $currentFlash);
$session->getFlashBag()->add($currentFlash['engine'], $currentFlash);
$renders[$type . $key] = $this->alertifyFilter($session);
}
} else {
foreach ($flash as $key => $content) {
if (is_array($content)) {
$context = isset($content['context']) ? $content['context'] : null;
$defaultParameters = self::getDefaultParametersFromContext($context);
$parameters = array_merge($defaultParameters, $content);
} else {
$defaultParameters = self::getDefaultParametersFromContext(null);
$parameters = array_merge($defaultParameters, array('body' => $content));
}
$parameters['type'] = $type;
$renders[$type . $key] = $environment->render('AvAlertifyBundle:Modal:' . $parameters['engine'] . '.html.twig', $parameters);
}
}
}
return implode(' ', $renders);
}
public function notify(RequestVerifiedEvent $event)
{
$payment = $event->getPayment();
$status = $event->getStatus()->getValue();
switch ($status) {
case GetHumanStatus::STATUS_AUTHORIZED:
case GetHumanStatus::STATUS_CAPTURED:
case GetHumanStatus::STATUS_REFUNDED:
$this->repository->clearCart();
$type = 'success';
break;
case GetHumanStatus::STATUS_CANCELED:
case GetHumanStatus::STATUS_EXPIRED:
case GetHumanStatus::STATUS_FAILED:
$type = 'danger';
break;
case GetHumanStatus::STATUS_PENDING:
case GetHumanStatus::STATUS_SUSPENDED:
$this->repository->clearCart();
$type = 'warning';
break;
case GetHumanStatus::STATUS_NEW:
case GetHumanStatus::STATUS_UNKNOWN:
$this->repository->clearCart();
$type = 'info';
break;
default:
throw new \RuntimeException('Unknown status ' . $status);
}
$formatter = new \NumberFormatter($this->translator->getLocale(), \NumberFormatter::CURRENCY);
$this->session->getFlashBag()->add($type, $this->translator->trans('flash.payment.' . $type, ['%status%' => $this->translator->trans('meta.status.' . $status), '%amount%' => $formatter->formatCurrency($payment->getTotalAmount() / 100, $payment->getCurrencyCode())]));
}
public function testAddFlashMessage()
{
$type = 'test_type';
$message = 'Test Message';
$this->assertEmpty($this->session->getFlashBag()->all());
$this->manager->addFlashMessage($type, $message);
$this->assertEquals([$type => [$message]], $this->session->getFlashBag()->all());
}
public function onKernelException(GetResponseForExceptionEvent $event)
{
$exception = $event->getException();
if ($exception instanceof NoAdministrationException) {
$this->session->getFlashBag()->add('danger', $this->translator->trans('administration.none_found', array()));
$response = new RedirectResponse($this->router->generate('manage_administrations'));
$event->setResponse($response, 307);
}
}
/**
* Get the currently logged in user
*
* @throws AccessDeniedHttpException When no currently logged in user exists in the session
*
* @return User
*/
public function getUser()
{
$user = $this->tokenStorage->getToken()->getUser();
if (!$user instanceof User) {
$this->session->getFlashBag()->add(self::ERROR_TYPE, self::ERROR_MESSAGE);
throw new AccessDeniedHttpException(self::ERROR_MESSAGE);
}
return $this->entityManager->merge($user);
}
/**
* @param FilterResponseEvent $event
**/
public function onKernelResponse(FilterResponseEvent $event)
{
if ('html' === $this->responseFormat) {
return;
}
$flashBag = $this->session->getFlashBag();
$message = $flashBag->get(Constant::MESSAGE_SAVE, $flashBag->get(Constant::MESSAGE_UPDATE, $flashBag->get(Constant::MESSAGE_DELETE)));
$event->getResponse()->setContent($this->serializer->serialize($message, array(), $this->responseFormat));
}
/**
* @param null|string $type Message type. If null returns all types messages,
* otherwise returns messages only with given types.
* @return string
*/
public function renderMessages($type = null)
{
if ($type === null) {
$messages = $this->session->getFlashBag()->all();
} else {
$messages[$type] = $this->session->getFlashBag()->get($type);
}
return $this->environment->render('ArturDoruchFlashMessageBundle::messages.html.twig', array('messages' => $messages));
}
/**
* @Route("/", name="index")
* @Template
*
* @return Response
*/
public function indexAction(Request $request)
{
$form = $this->formFactory->create('add_event');
$form->handleRequest($request);
if ($form->isValid()) {
$this->session->getFlashBag()->add('success', 'Your event have been successfully added !');
$form = $this->formFactory->create('add_event');
}
return ['form' => $form->createView()];
}
/**
* @param GenericEvent $event
*/
public function preDelete(GenericEvent $event)
{
if (!($subject = $event->getSubject()) instanceof CustomerInterface) {
throw new UnexpectedTypeException($subject, 'Sylius\\Component\\Core\\Model\\CustomerInterface');
}
if ('*****@*****.**' === $subject->getEmail()) {
$this->session->getFlashBag()->add("error", "sylius_demo.account.prevent_delete");
$event->stopPropagation();
}
}
public function __construct(Container $container)
{
$this->container = $container;
$this->session = $this->container->get('session');
$this->flash = $this->session->getFlashBag();
$this->view = $this->container->get('view');
$this->request = $this->container->get('current_request');
$this->router = $this->container->get('router');
$this->config = $this->container->get('config');
$this->initialize();
}
/**
* @inheritdoc
*/
public function getAlerts()
{
$alerts = array();
foreach (self::getAlertTypes() as $type) {
$messages = $this->session->getFlashBag()->get($type);
if (!empty($messages)) {
$alerts = array_merge($alerts, $this->createAlertsForType($type, $messages));
}
}
return $alerts;
}
/**
* Test adding alert
*
* @depends testClassDefinition
*/
public function testAddAlert()
{
$this->extensionTwig->addError('Error');
$this->assertContains('Error', $this->session->getFlashBag()->get('danger', array()));
$this->extensionTwig->addWarning('Warning');
$this->assertContains('Warning', $this->session->getFlashBag()->get('warning', array()));
$this->extensionTwig->addSuccess('addSuccess');
$this->assertContains('addSuccess', $this->session->getFlashBag()->get('success', array()));
$this->extensionTwig->addInfo('addInfo');
$this->assertContains('addInfo', $this->session->getFlashBag()->get('info', array()));
}
protected function checkUnconfirmedEmail()
{
$token = $this->context->getToken();
$user = $token->getUser();
if (is_null($user->getEmailConfirmedAt())) {
$params = array('%url%' => $this->router->generate('lc_resend_confirmation_email'));
$title = $this->translator->trans('notification.unconfirmed.email.title');
$text = $this->translator->trans('notification.unconfirmed.email.shortText', $params);
$alert = sprintf("<strong>%s</strong> %s", $title, $text);
$this->session->getFlashBag()->add('alert.unconfirmed.email', $alert);
}
}
public function onKernelException(GetResponseForExceptionEvent $event)
{
$exception = $event->getException();
$attrs = $event->getRequest()->attributes;
$route = $attrs->get('_route', '');
$locale = $attrs->get('_locale', 'en');
if ($exception instanceof NotFoundHttpException && $route == 'fos_user_resetting_reset') {
$this->session->getFlashBag()->add('error', 'Your password reset request has expired.');
$response = new RedirectResponse($this->router->generate('fos_user_security_login'));
$event->setResponse($response);
}
}
private function loadFlashes()
{
if ($this->flashesLoaded) {
return;
}
foreach ($this->session->getFlashBag()->all() as $type => $flashes) {
foreach ($flashes as $flash) {
$this->notifications[] = new Notification($flash, $type);
}
}
$this->flashesLoaded = true;
}
/**
* @Route("/newsletter/new", name="newsletter_new")
*
* @return Response
*
* @throws \Exception
* @throws \Twig_Error
*/
public function newAction(Request $request)
{
$resolvedForm = $this->formFactory->create(new NewsletterCampaignFormType());
if ($request->isMethod("POST")) {
$resolvedForm->handleRequest($request);
if ($resolvedForm->isValid()) {
$newsletterCampaign = $resolvedForm->getData();
$this->newsletterCampaignManager->save($newsletterCampaign);
$this->session->getFlashBag()->add('message', 'Saved!');
}
}
return new Response($this->twig->render('AppBundle:Newsletter:new.html.twig', array('form' => $resolvedForm->createView(), '')));
}
/**
* Remove media item from user's watchlist
*
* @param Media $media
*/
public function removeItem(Media $media)
{
$user = $this->securityContext->getToken()->getUser();
if (!$user->getWatchlist()->contains($media)) {
$this->session->getFlashBag()->add('watchlist_notice', "you didn't have it!");
return;
}
$user->removeWatchlist($media);
$this->entityManager->persist($user);
$this->entityManager->flush();
$this->session->getFlashBag()->add('watchlist_notice', 'successfully removed!');
return;
}
/**
* When redirecting to the backend dashboard (while logged in),
* if the user does not have access change the redirect to the homepage.
*
* @param \Symfony\Component\HttpFoundation\RedirectResponse $response
*/
protected function handleNoBackendAccess(RedirectResponse $response)
{
$authCookie = $this->session->get('authentication');
if (!$this->authentication->isValidSession((string) $authCookie)) {
return;
}
$dashboardPath = $this->urlGenerator->generate('dashboard');
$dashboardAccess = $this->users->isAllowed('dashboard');
if ($response->getTargetUrl() === $dashboardPath && !$dashboardAccess) {
$this->session->getFlashBag()->clear();
$response->setTargetUrl($this->urlGenerator->generate('homepage'));
}
}
/**
* @param GetResponseEvent $event
*/
public function onKernelRequest(GetResponseEvent $event)
{
if (HttpKernelInterface::MASTER_REQUEST !== $event->getRequestType()) {
return;
}
$request = $event->getRequest();
if (!$this->isAdminRoute($request->getRequestUri())) {
return;
}
if ($request->getHost() !== $this->domainConfiguration->getHost()) {
// Add flash message for admin pages
$this->session->getFlashBag()->add('warning', 'multi_domain.host_override_active');
}
}
public function create($request, $response)
{
$formFactory = Forms::createFormFactory();
/* @var $form \Symfony\Component\Form\Form */
$form = $formFactory->create(new BookType());
$form->handleRequest();
if ($form->isValid()) {
$this->em->persist($form->getData());
$this->em->flush();
$this->session->getFlashBag()->add('notice', 'Book inserted');
$response = new RedirectResponse('/book');
return $response;
}
return $response->create($this->template->render('book/create.html.twig', ['title' => 'New Book', 'form' => $form->createView()]));
}
/**
* @param GetResponseEvent $event
**/
public function onKernelRequest(GetResponseEvent $event)
{
$url = $event->getRequest()->getRequestUri();
if ($this->tokenStorage->getToken() && $this->isAdminRoute($url)) {
$route = $event->getRequest()->get('_route');
if ($this->authorizationChecker->isGranted('IS_AUTHENTICATED_REMEMBERED') && $route != 'fos_user_change_password') {
$user = $this->tokenStorage->getToken()->getUser();
if ($user->isPasswordChanged() === false) {
$response = new RedirectResponse($this->router->generate('fos_user_change_password'));
$this->session->getFlashBag()->add(FlashTypes::ERROR, $this->translator->trans('kuma_admin.password_check.flash.error'));
$event->setResponse($response);
}
}
}
}
/**
* @param FilterControllerEvent $event
*/
public function onKernelController(FilterControllerEvent $event)
{
/**
* @var $controller Controller
*/
$controller = $event->getController();
/*
* $controller passed can be either a class or a Closure.
* This is not usual in Symfony but it may happen.
* If it is a class, it comes in array format
*/
if (!is_array($controller)) {
return;
}
if ($controller[0] instanceof ProductControllerInterface) {
$user = $controller[0]->get('security.token_storage')->getToken()->getUser();
// Checks if an order belongs to user
$orderId = $event->getRequest()->get('orderId');
if ($orderId) {
$order = $this->entityManager->getRepository('IlluminatiOrderBundle:User_order')->findOneBy(['hostOrderId' => $orderId, 'usersId' => $user->getId(), 'deleted' => 0]);
if (!$order) {
throw new NotFoundHttpException('Order not found!');
}
$redirectUrl = $controller[0]->generateUrl('host_order_summary', ['id' => $orderId]);
$closeDate = $order->getHostOrderId()->getCloseDate();
$now = new \DateTime('now');
if ($closeDate < $now) {
$this->session->getFlashBag()->add('info', $this->translator->trans('product.order_expired'));
// redirect to summary if order is expired
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
// redirect to summary if order is closed or confirmed
if ($order->getHostOrderId()->getStateId() == 0) {
$this->session->getFlashBag()->add('info', $this->translator->trans('product.order_closed'));
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
}
// Load cart items from database
$cart = $controller[0]->get('cart.provider');
if ($cart->getStorage() === null) {
$cart->load($user->getId(), $orderId);
}
}
}
public function onKernelException(GetResponseForExceptionEvent $event)
{
$exception = $event->getException();
if (!$exception instanceof RedirectableException) {
return;
}
if ($this->logger) {
$this->logger->error(sprintf('RedirectableException: %s%s -> redirecting to %s [line: %s, file: %s]', $exception->getMessage(), $exception->getPrevious() ? sprintf('(%s)', $exception->getPrevious()->getMessage()) : '', $exception->getPath(), $exception->getLine(), $exception->getFile()));
}
// @TODO - check for path
$response = new RedirectResponse($exception->getPath());
if ($exception->getMessage()) {
$this->session->getFlashBag()->add(Notification::TYPE_ERROR, $exception->getMessage());
}
$event->setResponse($response);
}
/**
* @param string $error
* @return \Eccube\Service\CartService
*/
public function setError($error = null)
{
$this->error = $error;
$this->session->getFlashBag()->add('eccube.front.cart.error', $error);
$this->session->getFlashBag()->set('eccube.front.request.error', $error);
return $this;
}
/**
* @param $tokenParameters
* @throws \Exception
*/
protected function persistToken($tokenParameters)
{
if ($tokenParameters['screen_name'] !== $this->getUser()->getTwitterUserName()) {
throw new \Exception('The token doesn\'t match ' . 'with the declared twitter username of current user');
}
$tokens = $this->tokenRepository->findBy(['oauthToken' => $tokenParameters['oauth_token']]);
if (count($tokens) === 0) {
$token = $this->tokenRepository->makeToken($tokenParameters);
/** @var \WTW\UserBundle\Entity\User $user */
$user = $this->getUser();
$phantomUser = $this->userManager->findUserBy(['twitter_username' => $tokenParameters['screen_name'], 'twitterID' => $tokenParameters['user_id']]);
if (!is_null($phantomUser)) {
$phantomUser->setTwitterID(null);
$this->entityManager->persist($phantomUser);
$this->entityManager->flush();
}
$this->userManager->updateUserTwitterCredentials($user, $tokenParameters);
$token->addUser($user);
$this->entityManager->persist($token);
$this->entityManager->flush();
$user->addToken($token);
$this->entityManager->persist($user);
$this->entityManager->flush();
$noticeMessage = 'successful_access_token_persistence';
} else {
$noticeMessage = 'existing_access_token';
}
$this->session->getFlashBag()->add('notice', $noticeMessage);
}
/**
* @param GetResponseEvent $event
* @param string $message
*/
private function redirectToLogin(GetResponseEvent $event, $message)
{
$this->session->getFlashBag()->add('error', $message);
$url = $this->router->generate('login_route');
$response = new RedirectResponse($url);
$event->setResponse($response);
}
