src/Menu/Builder.php line 285

  1. <?php
  2. /**
  3.  * This file is part of the NautilePlus package.
  4.  *
  5.  * (c) Nicolas SOBOLEV <nicolas.sobolev@nautile.sarl>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  11. namespace App\Menu;
  13. use Knp\Menu\FactoryInterface;
  14. use Knp\Menu\ItemInterface;
  15. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  16. use Symfony\Bundle\SecurityBundle\Security;
  17. use Symfony\Contracts\Translation\TranslatorInterface;
  19. /**
  20.  * Menu builder engine.
  21.  *
  22.  * @see https://symfony.com/doc/current/bundles/KnpMenuBundle/menu_builder_service.html
  23.  *
  24.  * @author Nicolas SOBOLEV <nicolas.sobolev@nautile.sarl>
  25.  */
  26. class Builder
  27. {
  28.     /**
  29.      * Menu builder factory.
  30.      *
  31.      * @var FactoryInterface
  32.      */
  33.     private $factory;
  35.     /**
  36.      * Translation service.
  37.      *
  38.      * @var TranslatorInterface
  39.      */
  40.     private $translator;
  42.     /**
  43.      * Url generation service.
  44.      *
  45.      * @var UrlGeneratorInterface
  46.      */
  47.     private $urlGenerator;
  49.     /**
  50.      * Security service.
  51.      *
  52.      * @var Security
  53.      */
  54.     private $security;
  56.     /**
  57.      * Service constructor.
  58.      *
  59.      * @param FactoryInterface      $factory      Knp menu factory
  60.      * @param UrlGeneratorInterface $urlGenerator Url generation service
  61.      * @param TranslatorInterface   $translator   Translation service
  62.      * @param Security              $security     Security service
  63.      */
  64.     public function __construct(FactoryInterface $factory, UrlGeneratorInterface $urlGenerator, TranslatorInterface $translator, Security $security)
  65.     {
  66.         $this->factory = $factory;
  67.         $this->urlGenerator = $urlGenerator;
  68.         $this->translator = $translator;
  69.         $this->security = $security;
  70.     }
  72.     /**
  73.      * Parses and formats the menu attributes.
  74.      *
  75.      * @param array $menuItem Reference of menu item
  76.      *
  77.      * @return array Menu item attributes
  78.      */
  79.     private function prepareMenuAttributes(&$menuItem): array
  80.     {
  81.         $menuAttr = [
  82.             // default attribures here ...
  83.         ];
  85.         if (isset($menuItem['name'])) {
  86.             $menuAttr['name'] = $menuItem['name'];
  87.         }
  89.         // configured attributes
  90.         if (isset($menuItem['attributes']) && is_array($menuItem['attributes'])) {
  91.             foreach ($menuItem['attributes'] as $attrName => $attrValue) {
  92.                 $menuAttr[$attrName] = $attrValue;
  93.             }
  94.         }
  96.         return $menuAttr;
  97.     }
  99.     /**
  100.      * Creates child of menu object.
  101.      *
  102.      * @param ItemInterface $menu       Reference of the Menu object that is being generated
  103.      * @param array         $menuItem   Reference of the menu child item to be addad to the menu object
  104.      * @param array         $menuParams Reference of the parameter array of child menu item
  105.      *
  106.      * @return Builder Current menu builder instance
  107.      */
  108.     private function processNode(ItemInterface &$menu, &$menuItem, &$menuParams): self
  109.     {
  110.         if (isset($menuItem['children'])) {
  111.             $menuParams['extras']['expanded'] = true;
  112.             if (isset($menuItem['expanded'])) {
  113.                 $menuParams['extras']['expanded'] = $menuItem['expanded'];
  114.             }
  115.         }
  117.         $menu->addChild($menuItem['name'], $menuParams);
  119.         if (isset($menuItem['children'])) {
  120.             $this->fillMenuNodes($menu[$menuItem['name']], $menuItem['children']);
  121.         }
  123.         return $this;
  124.     }
  126.     /**
  127.      * Transforms the table representation of menu to the randerable object.
  128.      *
  129.      * @param ItemInterface $menu     Reference of the Menu object
  130.      * @param array         $menuData Reference of the table representation of the menu
  131.      *
  132.      * @return Builder Current menu builder instance
  133.      */
  134.     private function fillMenuNodes(ItemInterface &$menu, array &$menuData): self
  135.     {
  136.         $itemIndex = 0;
  138.         foreach ($menuData as $menuItem) {
  139.             $menuParams = [];
  141.             // whether this item is activated
  142.             if (isset($menuItem['current'])) {
  143.                 $menuParams['current'] = $menuItem['current'];
  144.             }
  146.             // @TODO
  147.             $translationDomain = 'navigation';
  149.             if (array_key_exists('translation_domain', $menuItem)) {
  150.                 $translationDomain = $menuItem['translation_domain'];
  151.             }
  153.             // menu action URL
  154.             $menuParams['uri'] = null; // no action by default
  156.             // generate the URI with the value of the "route" attribute
  157.             if (isset($menuItem['route'])) {
  158.                 $routeParams = [];
  160.                 if (isset($menuItem['routeParams'])) {
  161.                     $routeParams = $menuItem['routeParams'];
  162.                 }
  164.                 $menuParams['uri'] = $this->urlGenerator->generate($menuItem['route'], $routeParams, UrlGeneratorInterface::ABSOLUTE_URL);
  165.             }
  167.             // the value of the "uri" attribute (if not empty) will override
  168.             // the uri generated with the value of the "route" attribute
  169.             if (isset($menuItem['uri'])) {
  170.                 $menuParams['uri'] = $menuItem['uri'];
  171.             }
  173.             // item [name] attribute (could be used as anchor, hashtag etc)
  174.             if (isset($menuItem['name'])) {
  175.                 $menuParams['name'] = $menuItem['name'];
  176.             }
  178.             // menu item label
  179.             $menuParams['label'] = '';
  180.             if (isset($menuItem['label'])) {
  181.                 $menuParams['label'] = $this->translator->trans($menuItem['label'], [], $translationDomain);
  182.             }
  184.             // menu item attributes
  185.             $menuParams['attributes'] = $this->prepareMenuAttributes($menuItem);
  187.             // if (!isset($menuItem['iconClass'])) {
  188.             //     // set the default icon using the translation file
  189.             //     // the translation key should be the same as for label except for "label"
  190.             //     // is replaced by "icon"
  191.             //     // $menuParams['extras']['icon'] = $this->translator->trans(
  192.             //     //     str_replace('label', 'icon', $menuItem['name']),
  193.             //     //     [],
  194.             //     //     $translationDomain
  195.             //     // );
  197.             // icon property
  198.             if (isset($menuItem['icon'])) {
  199.                 $menuParams['extras']['icon'] = $this->translator->trans($menuItem['icon'], [], $translationDomain);
  200.             }
  202.             // hint property
  203.             if (isset($menuItem['hint'])) {
  204.                 $menuParams['extras']['hint'] = $this->translator->trans($menuItem['hint'], [], $translationDomain);
  205.             }
  207.             // // set the default uri hash
  208.             // // the translation key should be the same as for label except for "label"
  209.             // // is replaced by "hash"
  210.             // $menuParams['extras']['hash'] = $this->translator->trans(
  211.             //     str_replace('label', 'hash', $menuItem['name']),
  212.             //     [],
  213.             //     $translationDomain
  214.             // );
  216.             // // hash property overrides the default behaviour
  217.             // if (isset($menuItem['hash'])) {
  218.             //     $menuParams['extras']['hash'] = $menuItem['hash'];
  219.             // }
  221.             // if (isset($menuItem['options'])) {
  222.             //     $menuParams['extras']['options'] = $menuItem['options'];
  223.             // }
  225.             // $menuParams['extras']['index'] = $itemIndex++;
  227.             $this->processNode($menu, $menuItem, $menuParams);
  228.         }
  230.         return $this;
  231.     }
  233.     /**
  234.      * Menu node generator.
  235.      *
  236.      * @param array $menuData   Menu utems table
  237.      * @param array $attributes Attributes for menu items
  238.      *
  239.      * @return ItemInterface Processed menu object
  240.      */
  241.     private function generateMenu(array &$menuData, array $attributes = []): ItemInterface
  242.     {
  243.         $menu = $this->factory->createItem('root');
  245.         foreach ($attributes as $attrName => $attrValue) {
  246.             $menu->setChildrenAttribute($attrName, $attrValue);
  247.         }
  249.         $this->fillMenuNodes($menu, $menuData);
  251.         return $menu;
  252.     }
  254.     // /**
  255.     //  * Sidebar menu service.
  256.     //  *
  257.     //  * @param UrlGeneratorInterface $urlGenerator Url generation service
  258.     //  * @param TranslatorInterface   $translator   Translation service
  259.     //  * @param SidebarMenu           $sidebarMenu  Sidebar menu items mapping service
  260.     //  *
  261.     //  * @return ItemInterface generated menu item
  262.     //  */
  263.     // public function createSidebarMenu(UrlGeneratorInterface $urlGenerator, TranslatorInterface $translator, SidebarMenu $sidebarMenu)
  264.     // {
  265.     //     $this->urlGenerator = $urlGenerator;
  266.     //     $this->translator = $translator;
  268.     //     $items = $sidebarMenu->items;
  270.     //     $attributes = [
  271.     //         'class' => 'mdc-list',
  272.     //         'aria-hidden' => 'true',
  273.     //         'aria-orientation' => 'vertical',
  274.     //         'data-nautile-plus-list' => '',
  275.     //     ];
  277.     //     return $this->generateMenu($items, $attributes);
  278.     // }
  280.     /**
  281.      * Main menu service.
  282.      *
  283.      * @return ItemInterface generated menu item
  284.      */
  285.     public function createMainMenu(array $options): ItemInterface
  286.     {
  287.         $menu = new MainMenu($options, $this->security);
  289.         return $this->generateMenu($menu->items, $menu->attributes);
  290.     }
  292.     /**
  293.      * Userbox menu service.
  294.      *
  295.      * @return ItemInterface generated menu item
  296.      */
  297.     public function createUserboxMenu(array $options): ItemInterface
  298.     {
  299.         $menu = new UserboxMenu($options, $this->security);
  301.         return $this->generateMenu($menu->items, $menu->attributes);
  302.     }
  304.     // /**
  305.     //  * Settings menu service.
  306.     //  *
  307.     //  * @param UrlGeneratorInterface $urlGenerator Url generation service
  308.     //  * @param TranslatorInterface   $translator   Translation service
  309.     //  * @param BaseMenu              $menu         Menu items mapping service
  310.     //  *
  311.     //  * @return ItemInterface generated menu item
  312.     //  */
  313.     // public function createContextMenu(UrlGeneratorInterface $urlGenerator, TranslatorInterface $translator, BaseMenu $menu)
  314.     // {
  315.     //     $this->urlGenerator = $urlGenerator;
  316.     //     $this->translator = $translator;
  318.     //     $items = $menu->items;
  320.     //     $attributes = [
  321.     //         // 'class' => 'mdc-list',
  322.     //         // 'aria-hidden' => 'true',
  323.     //         // 'aria-orientation' => 'vertical',
  324.     //         // 'data-nautile-plus-list' => '',
  325.     //         // 'tabindex' => '-1',
  326.     //     ];
  328.     //     return $this->generateMenu($items, $attributes);
  329.     // }
  330. }