vendor/easycorp/easyadmin-bundle/src/Twig/EasyAdminTwigExtension.php line 105

Open in your IDE?
  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Twig;
  5. use Doctrine\ORM\Mapping\ClassMetadata;
  6. use EasyCorp\Bundle\EasyAdminBundle\Configuration\ConfigManager;
  7. use EasyCorp\Bundle\EasyAdminBundle\Router\EasyAdminRouter;
  8. use EasyCorp\Bundle\EasyAdminBundle\Security\AuthorizationChecker;
  9. use Symfony\Component\HttpKernel\Kernel;
  10. use Symfony\Component\Intl\Countries;
  11. use Symfony\Component\Intl\Exception\MissingResourceException;
  12. use Symfony\Component\Intl\Intl;
  13. use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
  14. use Symfony\Component\Security\Http\Logout\LogoutUrlGenerator;
  15. use Symfony\Contracts\Translation\TranslatorInterface;
  16. use Twig\Environment;
  17. use Twig\Extension\AbstractExtension;
  18. use Twig\TwigFilter;
  19. use Twig\TwigFunction;
  21. /**
  22.  * Defines the filters and functions used to render the bundle's templates.
  23.  *
  24.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  25.  */
  26. class EasyAdminTwigExtension extends AbstractExtension
  27. {
  28.     private $configManager;
  29.     private $propertyAccessor;
  30.     private $easyAdminRouter;
  31.     private $debug;
  32.     private $logoutUrlGenerator;
  33.     /** @var TranslatorInterface|null */
  34.     private $translator;
  35.     private $authorizationChecker;
  37.     public function __construct(ConfigManager $configManager, PropertyAccessorInterface $propertyAccessor, EasyAdminRouter $easyAdminRouter, bool $debug, ?LogoutUrlGenerator $logoutUrlGenerator, $translator, AuthorizationChecker $authorizationChecker)
  38.     {
  39.         $this->configManager = $configManager;
  40.         $this->propertyAccessor = $propertyAccessor;
  41.         $this->easyAdminRouter = $easyAdminRouter;
  42.         $this->debug = $debug;
  43.         $this->logoutUrlGenerator = $logoutUrlGenerator;
  44.         $this->translator = $translator;
  45.         $this->authorizationChecker = $authorizationChecker;
  46.     }
  48.     /**
  49.      * {@inheritdoc}
  50.      */
  51.     public function getFunctions()
  52.     {
  53.         return [
  54.             new TwigFunction('easyadmin_render_field_for_*_view', [$this, 'renderEntityField'], ['is_safe' => ['html'], 'needs_environment' => true]),
  55.             new TwigFunction('easyadmin_config', [$this, 'getBackendConfiguration']),
  56.             new TwigFunction('easyadmin_entity', [$this, 'getEntityConfiguration']),
  57.             new TwigFunction('easyadmin_path', [$this, 'getEntityPath']),
  58.             new TwigFunction('easyadmin_action_is_enabled', [$this, 'isActionEnabled']),
  59.             new TwigFunction('easyadmin_action_is_enabled_for_*_view', [$this, 'isActionEnabled']),
  60.             new TwigFunction('easyadmin_get_action', [$this, 'getActionConfiguration']),
  61.             new TwigFunction('easyadmin_get_action_for_*_view', [$this, 'getActionConfiguration']),
  62.             new TwigFunction('easyadmin_get_actions_for_*_item', [$this, 'getActionsForItem']),
  63.             new TwigFunction('easyadmin_logout_path', [$this, 'getLogoutPath']),
  64.             new TwigFunction('easyadmin_read_property', [$this, 'readProperty']),
  65.             new TwigFunction('easyadmin_is_granted', [$this, 'isGranted']),
  66.         ];
  67.     }
  69.     /**
  70.      * {@inheritdoc}
  71.      */
  72.     public function getFilters()
  73.     {
  74.         $filters = [
  75.             new TwigFilter('easyadmin_truncate', [$this, 'truncateText'], ['needs_environment' => true]),
  76.             new TwigFilter('easyadmin_urldecode', 'urldecode'),
  77.             new TwigFilter('easyadmin_form_hidden_params', [$this, 'getFormHiddenParams']),
  78.             new TwigFilter('easyadmin_filesize', [$this, 'fileSize']),
  79.         ];
  81.         if (Kernel::VERSION_ID >= 40200) {
  82.             $filters[] = new TwigFilter('transchoice', [$this, 'transchoice']);
  83.         }
  85.         return $filters;
  86.     }
  88.     public function fileSize(int $bytes): string
  89.     {
  90.         $size = ['B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
  91.         $factor = (int) floor(log($bytes) / log(1024));
  93.         return (int) ($bytes / (1024 ** $factor)).@$size[$factor];
  94.     }
  96.     /**
  97.      * Returns the entire backend configuration or the value corresponding to
  98.      * the provided key. The dots of the key are automatically transformed into
  99.      * nested keys. Example: 'assets.css' => $config['assets']['css'].
  100.      *
  101.      * @param string|null $key
  102.      *
  103.      * @return mixed
  104.      */
  105.     public function getBackendConfiguration($key = null)
  106.     {
  107.         return $this->configManager->getBackendConfig($key);
  108.     }
  110.     /**
  111.      * Returns the entire configuration of the given entity.
  112.      *
  113.      * @param string $entityName
  114.      *
  115.      * @return array|null
  116.      */
  117.     public function getEntityConfiguration($entityName)
  118.     {
  119.         return null !== $this->getBackendConfiguration('entities.'.$entityName)
  120.             ? $this->configManager->getEntityConfig($entityName)
  121.             : null;
  122.     }
  124.     /**
  125.      * @param object|string $entity
  126.      * @param string        $action
  127.      * @param array         $parameters
  128.      *
  129.      * @return string
  130.      */
  131.     public function getEntityPath($entity, $action, array $parameters = [])
  132.     {
  133.         return $this->easyAdminRouter->generate($entity, $action, $parameters);
  134.     }
  136.     /**
  137.      * Renders the value stored in a property/field of the given entity. This
  138.      * function contains a lot of code protections to avoid errors when the
  139.      * property doesn't exist or its value is not accessible. This ensures that
  140.      * the function never generates a warning or error message when calling it.
  141.      *
  142.      * @param Environment $twig
  143.      * @param string      $view          The view in which the item is being rendered
  144.      * @param string      $entityName    The name of the entity associated with the item
  145.      * @param object      $item          The item which is being rendered
  146.      * @param array       $fieldMetadata The metadata of the actual field being rendered
  147.      *
  148.      * @return string
  149.      *
  150.      * @throws \Exception
  151.      */
  152.     public function renderEntityField(Environment $twig, $view, $entityName, $item, array $fieldMetadata)
  153.     {
  154.         $entityConfiguration = $this->configManager->getEntityConfig($entityName);
  155.         $hasCustomTemplate = 0 !== strpos($fieldMetadata['template'], '@EasyAdmin/');
  156.         $templateParameters = [];
  158.         try {
  159.             $templateParameters = $this->getTemplateParameters($entityName, $view, $fieldMetadata, $item);
  161.             // if the field defines a custom template, render it (no matter if the value is null or inaccessible)
  162.             if ($hasCustomTemplate) {
  163.                 return $twig->render($fieldMetadata['template'], $templateParameters);
  164.             }
  166.             if (false === $templateParameters['is_accessible']) {
  167.                 return $twig->render($entityConfiguration['templates']['label_inaccessible'], $templateParameters);
  168.             }
  170.             if (null === $templateParameters['value']) {
  171.                 return $twig->render($entityConfiguration['templates']['label_null'], $templateParameters);
  172.             }
  174.             if (empty($templateParameters['value']) && \in_array($fieldMetadata['dataType'], ['image', 'file', 'array', 'simple_array'])) {
  175.                 return $twig->render($templateParameters['entity_config']['templates']['label_empty'], $templateParameters);
  176.             }
  178.             return $twig->render($fieldMetadata['template'], $templateParameters);
  179.         } catch (\Exception $e) {
  180.             if ($this->debug) {
  181.                 throw $e;
  182.             }
  184.             return $twig->render($entityConfiguration['templates']['label_undefined'], $templateParameters);
  185.         }
  186.     }
  188.     private function getTemplateParameters($entityName, $view, array $fieldMetadata, $item)
  189.     {
  190.         $fieldName = $fieldMetadata['property'];
  191.         $fieldType = $fieldMetadata['dataType'];
  193.         $parameters = [
  194.             'backend_config' => $this->getBackendConfiguration(),
  195.             'entity_config' => $this->configManager->getEntityConfig($entityName),
  196.             'field_options' => $fieldMetadata,
  197.             'item' => $item,
  198.             'view' => $view,
  199.         ];
  201.         if ($this->propertyAccessor->isReadable($item, $fieldName)) {
  202.             $parameters['value'] = $this->propertyAccessor->getValue($item, $fieldName);
  203.             $parameters['is_accessible'] = true;
  204.         } else {
  205.             $parameters['value'] = null;
  206.             $parameters['is_accessible'] = false;
  207.         }
  209.         if ('image' === $fieldType) {
  210.             $parameters = $this->addImageFieldParameters($parameters);
  211.         }
  213.         if ('file' === $fieldType) {
  214.             $parameters = $this->addFileFieldParameters($parameters);
  215.         }
  217.         if ('association' === $fieldType) {
  218.             $parameters = $this->addAssociationFieldParameters($parameters);
  219.         }
  221.         if ('country' === $fieldType) {
  222.             $parameters['value'] = null !== $parameters['value'] ? strtoupper($parameters['value']) : null;
  223.             $parameters['country_name'] = $this->getCountryName($parameters['value']);
  224.         }
  226.         if ('avatar' === $fieldType) {
  227.             $parameters['image_height'] = $fieldMetadata['height'];
  229.             if ($fieldMetadata['is_image_url'] ?? false) {
  230.                 $parameters['image_url'] = $parameters['value'];
  231.             } else {
  232.                 $parameters['image_url'] = null === $parameters['value'] ? null : sprintf('https://www.gravatar.com/avatar/%s?s=%d&d=mp', md5($parameters['value']), $parameters['image_height']);
  233.             }
  234.         }
  236.         // when a virtual field doesn't define it's type, consider it a string
  237.         if (true === $fieldMetadata['virtual'] && null === $parameters['field_options']['dataType']) {
  238.             $parameters['value'] = (string) $parameters['value'];
  239.         }
  241.         return $parameters;
  242.     }
  244.     private function addImageFieldParameters(array $templateParameters)
  245.     {
  246.         // add the base path only to images that are not absolute URLs (http or https) or protocol-relative URLs (//)
  247.         if (null !== $templateParameters['value'] && 0 === preg_match('/^(http[s]?|\/\/)/i', $templateParameters['value'])) {
  248.             $templateParameters['value'] = isset($templateParameters['field_options']['base_path'])
  249.                 ? rtrim($templateParameters['field_options']['base_path'], '/').'/'.ltrim($templateParameters['value'], '/')
  250.                 : '/'.ltrim($templateParameters['value'], '/');
  251.         }
  253.         $templateParameters['uuid'] = md5($templateParameters['value']);
  255.         return $templateParameters;
  256.     }
  258.     private function addFileFieldParameters(array $templateParameters)
  259.     {
  260.         // add the base path only to files that are not absolute URLs (http or https) or protocol-relative URLs (//)
  261.         if (null !== $templateParameters['value'] && 0 === preg_match('/^(http[s]?|\/\/)/i', $templateParameters['value'])) {
  262.             $templateParameters['value'] = isset($templateParameters['field_options']['base_path'])
  263.                 ? rtrim($templateParameters['field_options']['base_path'], '/').'/'.ltrim($templateParameters['value'], '/')
  264.                 : '/'.ltrim($templateParameters['value'], '/');
  265.         }
  267.         $templateParameters['filename'] = $templateParameters['field_options']['filename'] ?? basename($templateParameters['value']);
  269.         return $templateParameters;
  270.     }
  272.     private function addAssociationFieldParameters(array $templateParameters)
  273.     {
  274.         $targetEntityConfig = $this->configManager->getEntityConfigByClass($templateParameters['field_options']['targetEntity']);
  275.         // the associated entity is not managed by EasyAdmin
  276.         if (null === $targetEntityConfig) {
  277.             return $templateParameters;
  278.         }
  280.         $isShowActionAllowed = !\in_array('show', $targetEntityConfig['disabled_actions']);
  282.         if ($templateParameters['field_options']['associationType'] & ClassMetadata::TO_ONE) {
  283.             if ($this->propertyAccessor->isReadable($templateParameters['value'], $targetEntityConfig['primary_key_field_name'])) {
  284.                 $primaryKeyValue = $this->propertyAccessor->getValue($templateParameters['value'], $targetEntityConfig['primary_key_field_name']);
  285.             } else {
  286.                 $primaryKeyValue = null;
  287.             }
  289.             // get the string representation of the associated *-to-one entity
  290.             if (method_exists($templateParameters['value'], '__toString')) {
  291.                 $templateParameters['value'] = (string) $templateParameters['value'];
  292.             } elseif (null !== $primaryKeyValue) {
  293.                 $templateParameters['value'] = sprintf('%s #%s', $targetEntityConfig['name'], $primaryKeyValue);
  294.             } else {
  295.                 $templateParameters['value'] = null;
  296.             }
  298.             // if the associated entity is managed by EasyAdmin, and the "show"
  299.             // action is enabled for the associated entity, display a link to it
  300.             if (null !== $targetEntityConfig && null !== $primaryKeyValue && $isShowActionAllowed) {
  301.                 $templateParameters['link_parameters'] = [
  302.                     'action' => 'show',
  303.                     'entity' => $targetEntityConfig['name'],
  304.                     // casting to string is needed because entities can use objects as primary keys
  305.                     'id' => (string) $primaryKeyValue,
  306.                 ];
  307.             }
  308.         }
  310.         if ($templateParameters['field_options']['associationType'] & ClassMetadata::TO_MANY) {
  311.             // if the associated entity is managed by EasyAdmin, and the "show"
  312.             // action is enabled for the associated entity, display a link to it
  313.             if (null !== $targetEntityConfig && $isShowActionAllowed) {
  314.                 $templateParameters['link_parameters'] = [
  315.                     'action' => 'show',
  316.                     'entity' => $targetEntityConfig['name'],
  317.                     'primary_key_name' => $targetEntityConfig['primary_key_field_name'],
  318.                 ];
  319.             }
  320.         }
  322.         return $templateParameters;
  323.     }
  325.     /**
  326.      * Checks whether the given 'action' is enabled for the given 'entity'.
  327.      *
  328.      * @param string $view
  329.      * @param string $action
  330.      * @param string $entityName
  331.      *
  332.      * @return bool
  333.      */
  334.     public function isActionEnabled($view, $action, $entityName)
  335.     {
  336.         return $this->configManager->isActionEnabled($entityName, $view, $action);
  337.     }
  339.     /**
  340.      * Returns the full action configuration for the given 'entity' and 'view'.
  341.      *
  342.      * @param string $view
  343.      * @param string $action
  344.      * @param string $entityName
  345.      *
  346.      * @return array
  347.      */
  348.     public function getActionConfiguration($view, $action, $entityName)
  349.     {
  350.         return $this->configManager->getActionConfig($entityName, $view, $action);
  351.     }
  353.     /**
  354.      * Returns the actions configured for each item displayed in the given view.
  355.      * This method is needed because some actions are displayed globally for the
  356.      * entire view (e.g. 'new' action in 'list' view).
  357.      *
  358.      * @param string $view
  359.      * @param string $entityName
  360.      *
  361.      * @return array
  362.      */
  363.     public function getActionsForItem($view, $entityName)
  364.     {
  365.         try {
  366.             $entityConfig = $this->configManager->getEntityConfig($entityName);
  367.         } catch (\Exception $e) {
  368.             return [];
  369.         }
  371.         $disabledActions = $entityConfig['disabled_actions'];
  372.         $viewActions = $entityConfig[$view]['actions'];
  374.         $actionsExcludedForItems = [
  375.             'list' => ['new', 'search'],
  376.             'edit' => [],
  377.             'new' => [],
  378.             'show' => [],
  379.         ];
  380.         $excludedActions = $actionsExcludedForItems[$view];
  382.         return array_filter($viewActions, function ($action) use ($excludedActions, $disabledActions) {
  383.             return !\in_array($action['name'], $excludedActions) && !\in_array($action['name'], $disabledActions);
  384.         });
  385.     }
  387.     /*
  388.      * Copied from the official Text Twig extension.
  389.      *
  390.      * code: https://github.com/twigphp/Twig-extensions/blob/master/lib/Twig/Extensions/Extension/Text.php
  391.      * author: Henrik Bjornskov <hb@peytz.dk>
  392.      * copyright holder: (c) 2009 Fabien Potencier
  393.      *
  394.      * @return string
  395.      */
  396.     public function truncateText(Environment $env, $value, $length = 64, $preserve = false, $separator = '...')
  397.     {
  398.         try {
  399.             $value = (string) $value;
  400.         } catch (\Exception $e) {
  401.             $value = '';
  402.         }
  404.         if (mb_strlen($value, $env->getCharset()) > $length) {
  405.             if ($preserve) {
  406.                 // If breakpoint is on the last word, return the value without separator.
  407.                 if (false === ($breakpoint = mb_strpos($value, ' ', $length, $env->getCharset()))) {
  408.                     return $value;
  409.                 }
  411.                 $length = $breakpoint;
  412.             }
  414.             return rtrim(mb_substr($value, 0, $length, $env->getCharset())).$separator;
  415.         }
  417.         return $value;
  418.     }
  420.     public function getFormHiddenParams(array $params, string $prefix): iterable
  421.     {
  422.         foreach ($params as $key => $value) {
  423.             $key = $prefix.'['.$key.']';
  425.             if (\is_array($value)) {
  426.                 yield from $this->getFormHiddenParams($value, $key);
  427.             } else {
  428.                 yield $key => $value;
  429.             }
  430.         }
  431.     }
  433.     /**
  434.      * Remove this filter when the Symfony's requirement is equal or greater than 4.2
  435.      * and use the built-in trans filter instead with a %count% parameter.
  436.      */
  437.     public function transchoice($message, $count, array $arguments = [], $domain = null, $locale = null)
  438.     {
  439.         if (null === $this->translator) {
  440.             return strtr($message, $arguments);
  441.         }
  443.         return $this->translator->trans($message, array_merge(['%count%' => $count], $arguments), $domain, $locale);
  444.     }
  446.     /**
  447.      * This reimplementation of Symfony's logout_path() helper is needed because
  448.      * when no arguments are passed to the getLogoutPath(), it's common to get
  449.      * exceptions and there is no way to recover from them in a Twig template.
  450.      */
  451.     public function getLogoutPath()
  452.     {
  453.         if (null === $this->logoutUrlGenerator) {
  454.             return;
  455.         }
  457.         try {
  458.             return $this->logoutUrlGenerator->getLogoutPath();
  459.         } catch (\Exception $e) {
  460.             return;
  461.         }
  462.     }
  464.     public function readProperty($objectOrArray, ?string $propertyPath)
  465.     {
  466.         if (null === $propertyPath) {
  467.             return null;
  468.         }
  470.         if ('__toString' === $propertyPath) {
  471.             try {
  472.                 return (string) $objectOrArray;
  473.             } catch (\Exception $e) {
  474.                 return null;
  475.             }
  476.         }
  478.         try {
  479.             return $this->propertyAccessor->getValue($objectOrArray, $propertyPath);
  480.         } catch (\Exception $e) {
  481.             return null;
  482.         }
  483.     }
  485.     public function isGranted($permissions, $subject = null): bool
  486.     {
  487.         return $this->authorizationChecker->isGranted($permissions, $subject);
  488.     }
  490.     private function getCountryName(?string $countryCode): ?string
  491.     {
  492.         if (null === $countryCode) {
  493.             return null;
  494.         }
  496.         // Compatibility with Symfony versions before 4.3
  497.         if (!class_exists(Countries::class)) {
  498.             return Intl::getRegionBundle()->getCountryName($countryCode) ?? null;
  499.         }
  501.         try {
  502.             return Countries::getName($countryCode);
  503.         } catch (MissingResourceException $e) {
  504.             return null;
  505.         }
  506.     }
  507. }