/**
* @param Url $url
* @return Url|object
* @throws \Doctrine\DBAL\ConnectionException
* @throws \Exception
*/
public function encode(Url $url)
{
$this->em->beginTransaction();
try {
$urlRepository = $this->em->getRepository('Rz\\Bundle\\UrlShortenerBundle\\Entity\\Url');
$entity = $urlRepository->findOneBy(['url' => $url->getUrl()]);
if ($entity) {
/** @var Url $url */
$url = $entity;
} else {
$url->setNew(true);
$this->em->persist($url);
$this->em->flush();
$url->setCode($this->encoder->encode($url->getId()));
$params = ['code' => $url->getCode()];
if (!$url->isDefaultSequence()) {
$params['index'] = $url->getSequence();
}
$url->setShortUrl($this->router->generate(UrlShortenerBundle::URL_GO, $params, UrlGeneratorInterface::ABSOLUTE_URL));
$this->em->persist($url);
$this->em->flush();
}
$this->em->getConnection()->commit();
return $url;
} catch (\Exception $e) {
$this->em->getConnection()->rollBack();
throw $e;
}
}
public function serializeRouteArrayToJson(JsonSerializationVisitor $visitor, array $route, array $type, Context $context)
{
if (is_array($route)) {
list($routeName, $routeParameters) = $route;
return $this->router->generate($routeName, $routeParameters);
}
}
/**
* @param string $route
* @param array $data
*
* @return RedirectResponse
*/
public function redirectToRoute($route, array $data = array())
{
if ('referer' === $route) {
return $this->redirectToReferer();
}
return $this->redirect($this->router->generate($route, $data));
}
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
if (!is_array($controller)) {
return;
}
$session = $event->getRequest()->getSession();
/** @var BaseController $ctrl */
$ctrl = $controller[0];
if (!is_object($ctrl) || !$ctrl instanceof BaseController) {
return;
}
// no loop for you, also allow username checking
if ($ctrl instanceof ProfileController && ($controller[1] == 'updateUsernameAction' || $controller[1] == 'checkUsernameAction')) {
return;
}
/** @var User $user */
$user = $ctrl->getUser();
if ($user && $this->isGUID($user->getUsername())) {
$session->getFlashBag()->add('error', "We recently changed our username restrictions. Your previous username is no longer valid. Please create a new one.");
$url = $this->router->generate('reset_username');
$event->setController(function () use($url) {
return new RedirectResponse($url);
});
}
}
public function onKernelRequest(GetResponseEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
$request = $event->getRequest();
$routes = $this->router->getRouteCollection();
$route = $routes->get($request->attributes->get('_route'));
if (!$route->getOption('requires_license')) {
return;
}
if ('active' != $request->get('lic') && $this->kernel->getEnvironment() == 'prod') {
// Checking for whitelisted users
try {
$user = $this->tokenStorage->getToken()->getUser();
$today = date('Y-m-d');
if ($user instanceof UserInterface) {
$whitelist = $this->kernel->getContainer()->getParameter('license_whitelist');
foreach ($whitelist as $allowed) {
if ($allowed['client_key'] == $user->getClientKey() && $today <= $allowed['valid_till']) {
return;
}
}
}
} catch (\Exception $e) {
// Do nothing
}
$url = $this->router->generate('atlassian_connect_unlicensed');
$response = new RedirectResponse($url);
$event->setResponse($response);
}
}
/**
* Creates a Response object to send upon a successful logout.
*
* @param Request $request
*
* @return Response never null
*/
public function onLogoutSuccess(Request $request)
{
if ($request->isXmlHttpRequest() or 'json' == $request->getRequestFormat()) {
return new JsonResponse(true);
}
return new RedirectResponse($this->router->generate('homepage'));
}
public function createCollection(QueryBuilder $qb, Request $request, $route, array $routeParams = array())
{
$page = $request->query->get(self::PARAMETER_NAME_PAGE_NUMBER, 1);
$count = $request->query->get(self::PARAMETER_NAME_PAGE_SIZE, self::PAGE_DEFAULT_COUNT);
if ($count > self::MAX_PAGE_COUNT) {
$count = self::MAX_PAGE_COUNT;
}
if ($count <= 0) {
$count = self::PAGE_DEFAULT_COUNT;
}
$adapter = new DoctrineORMAdapter($qb);
$pagerfanta = new Pagerfanta($adapter);
$pagerfanta->setMaxPerPage($count);
$pagerfanta->setCurrentPage($page);
$players = [];
foreach ($pagerfanta->getCurrentPageResults() as $result) {
$players[] = $result;
}
$paginatedCollection = new PaginatedCollection($players, $pagerfanta->getNbResults());
// make sure query parameters are included in pagination links
$routeParams = array_merge($routeParams, $request->query->all());
$createLinkUrl = function ($targetPage) use($route, $routeParams) {
return $this->router->generate($route, array_merge($routeParams, array(self::PARAMETER_NAME_PAGE_NUMBER => $targetPage)));
};
$paginatedCollection->addLink('self', $createLinkUrl($page));
$paginatedCollection->addLink('first', $createLinkUrl(1));
$paginatedCollection->addLink('last', $createLinkUrl($pagerfanta->getNbPages()));
if ($pagerfanta->hasNextPage()) {
$paginatedCollection->addLink('next', $createLinkUrl($pagerfanta->getNextPage()));
}
if ($pagerfanta->hasPreviousPage()) {
$paginatedCollection->addLink('prev', $createLinkUrl($pagerfanta->getPreviousPage()));
}
return $paginatedCollection;
}
/**
* @param Request $request
* @return \Symfony\Component\HttpFoundation\Response
* @throws \Exception
*/
public function __invoke(Request $request)
{
$user = $this->getUser();
if (!$user) {
throw $this->createAccessDeniedException();
}
$createWalletCommand = $this->createCreateWalletCommand();
$createWalletForm = $this->walletFormFactory->createCreateForm($createWalletCommand);
$createWalletForm->handleRequest($request);
if (!$createWalletForm->isValid()) {
$validationMsg = $this->getAllFormErrorMessagesAsString($createWalletForm);
$this->addFlash('error', $this->trans('create_transaction_form.flash.invalid_form') . ' ' . $validationMsg);
} else {
/** @var CreateWalletCommand $createWalletCommand */
$createWalletCommand = $createWalletForm->getData();
$createWalletCommand->setWalletOwnerId($user->getId()->getValue());
$createWalletCommand->setToken($user->getBlockCypherToken());
try {
$commandValidator = new CreateWalletCommandValidator();
$commandValidator->validate($createWalletCommand);
$this->commandBus->handle($createWalletCommand);
$this->addFlash('success', $this->trans('wallet.flash.create_successfully'));
$url = $this->router->generate('bc_app_wallet_wallet.index');
return new RedirectResponse($url);
} catch (\Exception $e) {
$this->addFlash('error', $e->getMessage());
}
}
return $this->renderWalletShowNew($request, $createWalletForm->createView());
}
/**
* {@inheritdoc}
*/
public function finishView(FormView $view, FormInterface $form, array $options)
{
$data = $view->parent->vars['value'];
if (is_object($data)) {
$view->vars['grid_url'] = $this->router->generate('oro_entity_relation', ['id' => $data->getId() ? $data->getId() : 0, 'entityName' => str_replace('\\', '_', get_class($data)), 'fieldName' => $form->getName()]);
}
}
/**
* {@inheritdoc}
*/
public function generateForOrderCheckoutState(OrderInterface $order, $parameters = [], $referenceType = self::ABSOLUTE_PATH)
{
if (!isset($this->routeCollection[$order->getCheckoutState()]['route'])) {
throw new RouteNotFoundException();
}
return $this->router->generate($this->routeCollection[$order->getCheckoutState()]['route'], $parameters, $referenceType);
}
/**
* {@inheritdoc}
*/
public function generateUrl(StoredFile $storedFile)
{
$storageKey = $storedFile->getStorageKey();
$storageKey .= '/' . $storedFile->getRepository()->getName();
$storageKey .= '/' . $storedFile->getFilename();
return $this->router->generate($this->routeName, array('storageKey' => $storageKey), RouterInterface::NETWORK_PATH);
}
/**
* @throws InvalidConfigurationException
*/
public function configureTabMenu(AdminInterface $admin, MenuItemInterface $menu, $action, AdminInterface $childAdmin = null)
{
if (!($subject = $admin->getSubject())) {
return;
}
if (!$subject instanceof RouteReferrersReadInterface && !$subject instanceof Route) {
throw new InvalidConfigurationException(sprintf('%s can only be used on subjects which implement Symfony\\Cmf\\Component\\Routing\\RouteReferrersReadInterface or Symfony\\Component\\Routing\\Route.', __CLASS__));
}
if ($subject instanceof PrefixInterface && !is_string($subject->getId())) {
// we have an unpersisted dynamic route
return;
}
$defaults = array();
if ($subject instanceof TranslatableInterface) {
if ($locale = $subject->getLocale()) {
$defaults['_locale'] = $locale;
}
}
try {
$uri = $this->router->generate($subject, $defaults);
} catch (RoutingExceptionInterface $e) {
// we have no valid route
return;
}
$menu->addChild($this->translator->trans('admin.menu_frontend_link_caption', array(), 'CmfRoutingBundle'), array('uri' => $uri, 'attributes' => array('class' => 'sonata-admin-menu-item', 'role' => 'menuitem'), 'linkAttributes' => array('class' => 'sonata-admin-frontend-link', 'role' => 'button', 'target' => '_blank', 'title' => $this->translator->trans('admin.menu_frontend_link_title', array(), 'CmfRoutingBundle'))));
}
/**
* @param HitEvent $event
*/
public function onHit(HitEvent $event)
{
if ($event->getMetadata()->reflection->getName() !== 'Sulu\\Bundle\\EventBundle\\Entity\\Event') {
return;
}
$locale = $this->requestAnalyzer->getCurrentLocalization()->getLocalization();
$document = $event->getHit()->getDocument();
$eventApiEntity = $this->eventManager->findByIdAndLocale($document->getId(), $locale);
if (!$eventApiEntity) {
return;
}
$startDate = $eventApiEntity->getStartDate();
$endDate = $eventApiEntity->getEndDate();
$categories = $eventApiEntity->getCategories();
$categoryTitles = array();
foreach ($categories as $category) {
$categoryTitles[] = $category->getName();
}
$startDateField = new Field('start_date', $startDate->format('c'), Field::TYPE_STRING);
$document->addField($startDateField);
if ($endDate) {
$endDateField = new Field('end_date', $endDate->format('c'), Field::TYPE_STRING);
$document->addField($endDateField);
}
$categoryTitleField = new Field('category_title', implode(', ', $categoryTitles), Field::TYPE_STRING);
$document->addField($categoryTitleField);
$url = $this->router->generate('sulu_events.detail', array('id' => $eventApiEntity->getId(), 'slug' => $eventApiEntity->getSlug()));
$document->setUrl($url);
}
/**
* @param array $items
* @param $shippingDetails
* @param string $intent
* @throws Exception
* @return null|string
*/
public function createPayment(array $items, Details $shippingDetails, $intent = PaymentConst::INTENT_SALE)
{
$apiContext = $this->connectionService->getApiContext();
$dispatcher = $this->connectionService->getDispatcher();
$dispatcher->dispatch(PaymentEvent::NEW_SETUP);
$successUrl = '';
$cancelUrl = '';
switch ($intent) {
case PaymentConst::INTENT_SALE:
$successUrl = $this->router->generate('paypal_payment_sale_success', array(), true);
$cancelUrl = $this->router->generate('paypal_payment_sale_cancel', array(), true);
break;
case PaymentConst::INTENT_AUTHORIZE:
$successUrl = $this->router->generate('paypal_payment_authorize_success', array(), true);
$cancelUrl = $this->router->generate('paypal_payment_authorize_cancel', array(), true);
break;
}
$redirectUrls = new RedirectUrls();
$redirectUrls->setReturnUrl($successUrl)->setCancelUrl($cancelUrl);
$payment = PaymentService::create($items, $shippingDetails, $intent, PaymentConst::METHOD_PAYPAL);
$payment->setRedirectUrls($redirectUrls);
$paymentEvent = new PayPalPaymentEvent($payment);
$dispatcher->dispatch(PaymentEvent::NEW_START, $paymentEvent);
$result = $payment->create($apiContext);
$paymentEvent = new PayPalPaymentEvent($result);
$dispatcher->dispatch(PaymentEvent::NEW_END, $paymentEvent);
$payment->create($apiContext);
$approvalUrl = $payment->getApprovalLink();
return $approvalUrl;
}
public function onMainTopMenuTools(HookRenderBlockEvent $event)
{
$isGranted = $this->securityContext->isGranted(["ADMIN"], [], [BoSearch::getModuleCode()], [AccessManager::VIEW]);
if ($isGranted) {
$event->add(['title' => $this->trans('Search product', [], BoSearch::DOMAIN_NAME), 'url' => $this->router->generate('bosearch.product.view')]);
}
}
/**
* @param \Twig_Environment $environment
* @param $node
* @param array $options
* @return string
*/
public function renderMenuItemTemplate(\Twig_Environment $environment, $node, $options = array())
{
$template = isset($options['template']) ? $options['template'] : false;
if ($template === false) {
$template = 'KunstmaanMenuBundle::menu-item.html.twig';
}
$active = false;
if ($node['type'] == MenuItem::TYPE_PAGE_LINK) {
$url = $this->router->generate('_slug', array('url' => $node['nodeTranslation']['url']));
if ($this->router->getContext()->getPathInfo() == $url) {
$active = true;
}
} else {
$url = $node['url'];
}
if ($node['type'] == MenuItem::TYPE_PAGE_LINK) {
if ($node['title']) {
$title = $node['title'];
} else {
$title = $node['nodeTranslation']['title'];
}
} else {
$title = $node['title'];
}
return $environment->render($template, array('menuItem' => $node, 'url' => $url, 'options' => $options, 'title' => $title, 'active' => $active));
}
/**
* @param Request $request
* @return Response
* @throws \Exception
*/
public function __invoke(Request $request)
{
$walletId = $request->get('walletId');
$walletDto = $this->walletServiceFacade->getWallet($walletId);
$this->checkAuthorizationForWallet($walletDto);
$createTransactionCommand = $this->createCreateTransactionCommand($walletId);
$user = $this->getUser();
$createTransactionForm = $this->transactionFormFactory->createCreateForm($createTransactionCommand, $user->getId()->getValue());
$createTransactionForm->handleRequest($request);
if (!$createTransactionForm->isValid()) {
$validationMsg = $this->getAllFormErrorMessagesAsString($createTransactionForm);
$this->addFlash('error', $this->trans('create_transaction_form.flash.invalid_form') . ' ' . $validationMsg);
} else {
/** @var CreateTransactionCommand $createTransactionCommand */
$createTransactionCommand = $createTransactionForm->getData();
try {
$commandValidator = new CreateTransactionCommandValidator();
$commandValidator->validate($createTransactionCommand);
$this->commandBus->handle($createTransactionCommand);
$this->addFlash('success', $this->trans('transaction.flash.create_successfully'));
$url = $this->router->generate('bc_app_wallet_transaction.index', array('walletId' => $createTransactionCommand->getWalletId()));
return new RedirectResponse($url);
} catch (\Exception $e) {
$this->addFlash('error', $e->getMessage());
}
}
$walletDto = $this->walletServiceFacade->getWallet($walletId);
return $this->renderTransactionShowNew($request, $createTransactionForm->createView(), $walletDto);
}
/**
* @param array $urlParameters
*
* @return string
*/
protected function getUrl(array $urlParameters = array())
{
if (null === $this->getRouteName()) {
throw new \RuntimeException('You need to provide route name, null given');
}
return $this->router->generate($this->getRouteName(), $urlParameters, true);
}
/**
* @param array $workshops
* @return array
*/
public function decorate(array $workshops = [])
{
$workshops = array_map(function (Workshop $workshop) {
return ["id" => $workshop->getSlug(), "start" => $workshop->getStartDate()->format(DateTime::ISO8601), "end" => $workshop->getEndDate()->format(DateTime::ISO8601), "title" => sprintf("%s: %s", $workshop->getCity(), $workshop->getTitle()), "editable" => false, "backgroundColor" => '', "url" => $this->router->generate("evento_show", ["slug" => $workshop->getSlug()])];
}, $workshops);
return $workshops;
}
/**
* Sends the Hydra header on each response.
*
* @param FilterResponseEvent $event
*/
public function onKernelResponse(FilterResponseEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
$event->getResponse()->headers->set('Link', sprintf('<%s>; rel="%sapiDocumentation"', $this->router->generate('api_hydra_vocab', [], UrlGeneratorInterface::ABSOLUTE_URL), ContextBuilder::HYDRA_NS));
}
public function onPostSerialize(ObjectEvent $event)
{
/**
* @var JsonSerializationVisitor $visitor
*/
$visitor = $event->getVisitor();
$object = $event->getObject();
$annotations = $this->annotationReader->getClassAnnotations(new \ReflectionObject($object));
$links = array();
foreach ($annotations as $annotation) {
if ($annotation instanceof Link) {
if ($annotation->url) {
$uri = $this->evaluate($annotation->url, $object);
} else {
$uri = $this->router->generate($annotation->route, $this->resolveParams($annotation->params, $object));
}
// allow a blank URI to be an optional link
if ($uri) {
$links[$annotation->name] = $uri;
}
}
}
if ($links) {
$visitor->addData('_links', $links);
}
}
public function lostPasswordMail(User $user)
{
$template = 'HomefinanceBundle:mailer:lost_password.txt.twig';
$url = $this->router->generate('reset_password_check_token', array('token' => $user->getConfirmationToken()), true);
$context = array('user' => $user, 'confirmationUrl' => $url);
$this->sendMessage($template, $context, $user->getEmail());
}
/**
* @param array $lessons
* @return array
*/
public function decorate(array $lessons = [])
{
$lessons = array_map(function (Lesson $lesson) {
return ["id" => sprintf("%s#%s", $lesson->getWorkshop()->getSlug(), $lesson->getId()), "start" => $lesson->getStartDate()->format("Y-m-d H:i:s"), "end" => $lesson->getEndDate()->format("Y-m-d H:i:s"), "editable" => false, "url" => sprintf("%s#%s", $this->router->generate("evento_show", ["slug" => $lesson->getWorkshop()->getSlug()]), $lesson->getId())];
}, $lessons);
return $lessons;
}
/**
* Intercept Exceptions and send valid ajax errors
* The idea is to NOT send HTML response when an issue(i.e.session expired) is encountered
* in an ajax request.
* @param GetResponseForExceptionEvent $event
*/
public function onKernelException(GetResponseForExceptionEvent $event)
{
// Get the exception object from the received event
$exception = $event->getException();
$request = $event->getRequest();
$isAjaxRequest = $request->isXmlHttpRequest();
if ($isAjaxRequest) {
$headers = [];
// handle session expired
if ($exception instanceof AuthenticationException) {
$loginUrl = $this->router->generate('fos_user_security_login');
// add custom header to redirect to login page on the client
$headers['relogin'] = true;
$headers['login-url'] = $loginUrl;
$response = new Response('Authentication Required', 200, $headers);
} elseif ($exception instanceof AccessDeniedException) {
$headers['not-authorized'] = true;
$response = new Response('Not authorized', 403, $headers);
} else {
$responseData = ['status' => false, 'msg' => 'Unknown Issue Encountered', 'data' => ['exception' => ['message' => $exception->getMessage(), 'file' => "{$exception->getFile()}:{$exception->getLine()}", 'trace' => $exception->getTraceAsString()]]];
$response = new Response(json_encode($responseData), 500, $headers);
}
$event->setResponse($response);
$event->stopPropagation();
}
}
/**
* {@inheritDoc}
*/
public function sendResettingEmailMessage(UserInterface $user)
{
$template = $this->parameters['resetting_password.template'];
$url = $this->router->generate('fos_user_resetting_reset', array('token' => $user->getConfirmationToken()), true);
$rendered = $this->templating->render($template, array('confirmationUrl' => $url, 'user' => $user));
$this->sendEmailMessage($rendered, $user->getEmail());
}
/**
* @param BreadcrumbItem $item
* @param array $variables
* @return ProcessedBreadcrumbItem
*/
public function process(BreadcrumbItem $item, $variables)
{
// Process the label
if ($item->getLabel()[0] === '$') {
$processedLabel = $this->parseValue($item->getLabel(), $variables);
} else {
$processedLabel = $this->translator->trans($item->getLabel());
}
// Process the route
// TODO: cache parameters extracted from current request
$params = [];
foreach ($this->requestStack->getCurrentRequest()->attributes as $key => $value) {
if ($key[0] !== '_') {
$params[$key] = $value;
}
}
foreach ($item->getRouteParams() ?: [] as $key => $value) {
if ($value[0] === '$') {
$params[$key] = $this->parseValue($value, $variables);
} else {
$params[$key] = $value;
}
}
if ($item->getRoute() !== null) {
$processedUrl = $this->router->generate($item->getRoute(), $params);
} else {
$processedUrl = null;
}
return new ProcessedBreadcrumbItem($processedLabel, $processedUrl);
}
/**
* {@inheritdoc}
*/
public function redirectToRoute(RequestConfiguration $configuration, $route, array $parameters = [])
{
if ('referer' === $route) {
return $this->redirectToReferer($configuration);
}
return $this->redirect($configuration, $this->router->generate($route, $parameters));
}
/**
* {@inheritdoc}
*/
protected function getUriFromNode(NodeInterface $node)
{
if ($node instanceof RouterNodeInterface && null !== $node->getRoute()) {
return $this->router->generate($node->getRoute(), $node->getRouteParameters(), $node->isRouteAbsolute());
}
return $node->getUri();
}
/**
* return the URL from extref
*
* @param ExtReference $extReference Extref
* @return string
* @throws \InvalidArgumentException
*/
public function getUrl(ExtReference $extReference)
{
if (!isset($this->mapping[$extReference->getRef()])) {
throw new \InvalidArgumentException(sprintf('Could not create URL from extref "%s"', json_encode($extReference)));
}
return $this->router->generate($this->mapping[$extReference->getRef()] . '.get', ['id' => $extReference->getId()], true);
}
/**
* @inheritdoc
*/
public function populateSitemap(SitemapPopulateEvent $event)
{
$event->getGenerator()->addUrl(new UrlConcrete($this->router->generate('harentius_blog_homepage', [], true), $this->homepage->getUpdatedAt(), UrlConcrete::CHANGEFREQ_WEEKLY, 1.0), 'pages');
// Pages
$pages = $this->pageRepository->findPublishedNotSlugOrdered($this->homepageSlug);
foreach ($pages as $page) {
$event->getGenerator()->addUrl(new UrlConcrete($this->router->generate('harentius_blog_show', ['slug' => $page->getSlug()], true), $page->getUpdatedAt(), UrlConcrete::CHANGEFREQ_MONTHLY, 0.5), 'pages');
}
// Articles
/** @var Article[] $articles */
$articles = $this->articleRepository->findBy(['isPublished' => true], ['publishedAt' => 'DESC']);
foreach ($articles as $article) {
$event->getGenerator()->addUrl(new UrlConcrete($this->router->generate('harentius_blog_show', ['slug' => $article->getSlug()], true), $article->getUpdatedAt(), UrlConcrete::CHANGEFREQ_MONTHLY, 0.9), 'articles');
}
// Categories
$addCategoriesRoutes = function ($categories) use($event, &$addCategoriesRoutes) {
foreach ($categories as $category) {
$event->getGenerator()->addUrl(new UrlConcrete($this->router->generate("harentius_blog_category_{$category['id']}", [], true), null, UrlConcrete::CHANGEFREQ_MONTHLY, 0.8), 'categories');
$addCategoriesRoutes($category['__children']);
}
};
$addCategoriesRoutes($this->categoryRepository->notEmptyChildrenHierarchy());
// Archives
foreach ($this->archive->getList() as $year => $months) {
foreach ($months as $number => $name) {
$event->getGenerator()->addUrl(new UrlConcrete($this->router->generate('harentius_blog_archive_month', ['year' => $year, 'month' => $number], true), null, UrlConcrete::CHANGEFREQ_MONTHLY, 0.6), 'archive');
}
$event->getGenerator()->addUrl(new UrlConcrete($this->router->generate('harentius_blog_archive_year', ['year' => $year], true), null, UrlConcrete::CHANGEFREQ_MONTHLY, 0.6), 'archive');
}
}
