vendor/sulu/sulu/src/Sulu/Component/Rest/ListBuilder/Metadata/ListXmlLoader.php line 138

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Component\Rest\ListBuilder\Metadata;
  14. use Sulu\Component\Rest\ListBuilder\FieldDescriptorInterface;
  15. use Sulu\Component\Util\XmlUtil;
  16. use Symfony\Component\Config\Util\XmlUtils;
  17. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  19. /**
  20.  * Parses data from xml and returns general list-builder metadata.
  21.  */
  22. class ListXmlLoader
  23. {
  24.     /**
  25.      * @var ParameterBagInterface
  26.      */
  27.     private $parameterBag;
  29.     public function __construct(ParameterBagInterface $parameterBag)
  30.     {
  31.         $this->parameterBag = $parameterBag;
  32.     }
  34.     public function load($resource)
  35.     {
  36.         $listMetadata = new ListMetadata();
  38.         $cwd = \getcwd();
  39.         // Necessary only for Windows, no effect on linux. Mute errors for PHP with chdir disabled to avoid E_WARNINGs
  40.         @\chdir(\dirname($resource));
  42.         $xmlDocument = XmlUtils::loadFile(
  43.             $resource,
  44.             function(\DOMDocument $dom) use ($resource) {
  45.                 $dom->documentURI = $resource;
  46.                 $dom->xinclude();
  48.                 return @$dom->schemaValidate(__DIR__ . '/Resources/schema/list-2.0.xsd');
  49.             }
  50.         );
  52.         // Necessary only for Windows, no effect on linux. Mute errors for PHP with chdir disabled to avoid E_WARNINGs
  53.         @\chdir($cwd);
  55.         $xpath = new \DOMXPath($xmlDocument);
  56.         $xpath->registerNamespace('x', 'http://schemas.sulu.io/list-builder/list');
  58.         $listMetadata->setResource($resource);
  59.         $listMetadata->setKey($xpath->query('/x:list/x:key')->item(0)->nodeValue);
  61.         foreach ($xpath->query('/x:list/x:properties/x:*') as $propertyNode) {
  62.             $listMetadata->addPropertyMetadata($this->loadPropertyMetadata($xpath, $propertyNode));
  63.         }
  65.         return $listMetadata;
  66.     }
  68.     /**
  69.      * Extracts attributes from dom-node to create a new property-metadata object.
  70.      *
  71.      * @return AbstractPropertyMetadata
  72.      */
  73.     private function loadPropertyMetadata(\DOMXPath $xpath, \DOMNode $propertyNode)
  74.     {
  75.         $propertyMetadata = null;
  76.         switch ($propertyNode->nodeName) {
  77.             case 'concatenation-property':
  78.                 $propertyMetadata = $this->loadConcatenationPropertyMetadata($xpath, $propertyNode);
  79.                 break;
  80.             case 'identity-property':
  81.                 $propertyMetadata = $this->loadIdentityPropertyMetadata($xpath, $propertyNode);
  82.                 break;
  83.             case 'group-concat-property':
  84.                 $propertyMetadata = $this->loadGroupConcatPropertyMetadata($xpath, $propertyNode);
  85.                 break;
  86.             case 'case-property':
  87.                 $propertyMetadata = $this->loadCasePropertyMetadata($xpath, $propertyNode);
  88.                 break;
  89.             case 'count-property':
  90.                 $propertyMetadata = $this->loadCountPropertyMetadata($xpath, $propertyNode);
  91.                 break;
  92.             case 'property':
  93.                 $propertyMetadata = $this->loadSinglePropertyMetadata($xpath, $propertyNode);
  94.                 break;
  95.             default:
  96.                 throw new \InvalidArgumentException(\sprintf(
  97.                     'The tag "%s" cannot be handled by this loader',
  98.                     $propertyNode->nodeName
  99.                 ));
  100.         }
  102.         if (null !== $translation = XmlUtil::getValueFromXPath('@translation', $xpath, $propertyNode)) {
  103.             $propertyMetadata->setTranslation($translation);
  104.         }
  106.         $propertyMetadata->setVisibility(
  107.             XmlUtil::getValueFromXPath(
  108.                 '@visibility',
  109.                 $xpath,
  110.                 $propertyNode,
  111.                 FieldDescriptorInterface::VISIBILITY_NO
  112.             )
  113.         );
  114.         $propertyMetadata->setSearchability(
  115.             XmlUtil::getValueFromXPath(
  116.                 '@searchability',
  117.                 $xpath,
  118.                 $propertyNode,
  119.                 FieldDescriptorInterface::SEARCHABILITY_NEVER
  120.             )
  121.         );
  122.         $propertyMetadata->setSortable(
  123.             XmlUtil::getBooleanValueFromXPath('@sortable', $xpath, $propertyNode, true)
  124.         );
  126.         $propertyMetadata->setWidth(
  127.             XmlUtil::getValueFromXPath(
  128.                 '@width',
  129.                 $xpath,
  130.                 $propertyNode,
  131.                 FieldDescriptorInterface::WIDTH_AUTO
  132.             )
  133.         );
  135.         if (null !== $type = XmlUtil::getValueFromXPath('x:transformer/@type', $xpath, $propertyNode)) {
  136.             $propertyMetadata->setType($type);
  137.         } elseif (null !== $type = XmlUtil::getValueFromXPath('@type', $xpath, $propertyNode)) {
  138.             @trigger_deprecation('sulu/sulu', '2.2', 'Attribute "type" of list property should not be used anymore! Use "<transformer type="..."/>" inside of property instead.');
  139.             $propertyMetadata->setType($type);
  140.         }
  142.         $transformerParamNodes = $xpath->query('x:transformer/x:params', $propertyNode);
  143.         if (\count($transformerParamNodes) > 0) {
  144.             $propertyMetadata->setTransformerTypeParameters(
  145.                 $this->getParameters(
  146.                     $xpath,
  147.                     $transformerParamNodes->item(0) // There can only be one transformer node
  148.                 )
  149.             );
  150.         }
  152.         $propertyMetadata->setFilterType((string) XmlUtil::getValueFromXPath('x:filter/@type', $xpath, $propertyNode));
  154.         $filterParamNodes = $xpath->query('x:filter/x:params', $propertyNode);
  155.         if (\count($filterParamNodes) > 0) {
  156.             $propertyMetadata->setFilterTypeParameters(
  157.                 $this->getParameters(
  158.                     $xpath,
  159.                     $filterParamNodes->item(0) // There can only be one filter node
  160.                 )
  161.             );
  162.         }
  164.         return $propertyMetadata;
  165.     }
  167.     private function loadIdentityPropertyMetadata(\DOMXPath $xpath, \DOMElement $propertyNode)
  168.     {
  169.         $field = $this->getField($xpath, $propertyNode);
  171.         $propertyMetadata = new IdentityPropertyMetadata(
  172.             (string) XmlUtil::getValueFromXPath('@name', $xpath, $propertyNode)
  173.         );
  175.         $propertyMetadata->setField($field);
  177.         return $propertyMetadata;
  178.     }
  180.     private function loadCasePropertyMetadata(\DOMXPath $xpath, \DOMElement $propertyNode)
  181.     {
  182.         $propertyMetadata = new CasePropertyMetadata(
  183.             (string) XmlUtil::getValueFromXPath('@name', $xpath, $propertyNode)
  184.         );
  186.         foreach ($xpath->query('x:field', $propertyNode) as $fieldNode) {
  187.             if (null === $case = $this->getField($xpath, $fieldNode)) {
  188.                 continue;
  189.             }
  191.             $propertyMetadata->addCase($case);
  192.         }
  194.         return $propertyMetadata;
  195.     }
  197.     private function loadGroupConcatPropertyMetadata(\DOMXPath $xpath, \DOMElement $propertyNode)
  198.     {
  199.         $field = $this->getField($xpath, $propertyNode);
  201.         $propertyMetadata = new GroupConcatPropertyMetadata(
  202.             (string) XmlUtil::getValueFromXPath('@name', $xpath, $propertyNode)
  203.         );
  205.         $propertyMetadata->setField($field);
  206.         $propertyMetadata->setGlue((string) XmlUtil::getValueFromXPath('@glue', $xpath, $propertyNode, ' '));
  207.         $propertyMetadata->setDistinct(XmlUtil::getBooleanValueFromXPath('@distinct', $xpath, $propertyNode) ?? false);
  209.         return $propertyMetadata;
  210.     }
  212.     private function loadSinglePropertyMetadata(\DOMXPath $xpath, \DOMNode $propertyNode)
  213.     {
  214.         $field = $this->getField($xpath, $propertyNode);
  216.         $propertyMetadata = new SinglePropertyMetadata(
  217.             (string) XmlUtil::getValueFromXPath('@name', $xpath, $propertyNode)
  218.         );
  220.         $propertyMetadata->setField($field);
  222.         return $propertyMetadata;
  223.     }
  225.     private function loadCountPropertyMetadata(\DOMXPath $xpath, \DOMNode $propertyNode)
  226.     {
  227.         $field = $this->getField($xpath, $propertyNode);
  229.         $propertyMetadata = new CountPropertyMetadata(
  230.             (string) XmlUtil::getValueFromXPath('@name', $xpath, $propertyNode)
  231.         );
  233.         $propertyMetadata->setField($field);
  234.         $propertyMetadata->setDistinct(XmlUtil::getBooleanValueFromXPath('@distinct', $xpath, $propertyNode) ?? false);
  236.         return $propertyMetadata;
  237.     }
  239.     private function loadConcatenationPropertyMetadata(\DOMXPath $xpath, \DOMNode $propertyNode)
  240.     {
  241.         $propertyMetadata = new ConcatenationPropertyMetadata(
  242.             (string) XmlUtil::getValueFromXPath('@name', $xpath, $propertyNode)
  243.         );
  245.         $propertyMetadata->setGlue((string) (XmlUtil::getValueFromXPath('@glue', $xpath, $propertyNode) ?? ' '));
  247.         foreach ($xpath->query('x:field', $propertyNode) as $fieldNode) {
  248.             if (null === $field = $this->getField($xpath, $fieldNode)) {
  249.                 continue;
  250.             }
  252.             $propertyMetadata->addField($field);
  253.         }
  255.         return $propertyMetadata;
  256.     }
  258.     /**
  259.      * Extracts filter type parameters from dom-node.
  260.      *
  261.      * @return ?array
  262.      */
  263.     protected function getParameters(\DOMXPath $xpath, \DOMNode $filterNode)
  264.     {
  265.         $parameters = [];
  266.         foreach ($xpath->query('x:param', $filterNode) as $paramNode) {
  267.             $name = XmlUtil::getValueFromXPath('@name', $xpath, $paramNode);
  268.             $type = XmlUtil::getValueFromXPath('@type', $xpath, $paramNode);
  270.             if ('collection' === $type) {
  271.                 $parameters[$name] = $this->getParameters($xpath, $paramNode);
  272.             } else {
  273.                 $value = $this->parameterBag->resolveValue(
  274.                     \trim((string) XmlUtil::getValueFromXPath('@value', $xpath, $paramNode))
  275.                 );
  277.                 if (null === $name) {
  278.                     $parameters[] = $value;
  279.                 } else {
  280.                     $parameters[$name] = $value;
  281.                 }
  282.             }
  283.         }
  285.         if (\count($parameters) > 0) {
  286.             return $parameters;
  287.         }
  289.         return null;
  290.     }
  292.     private function getField(\DOMXPath $xpath, \DOMElement $fieldNode)
  293.     {
  294.         if (null !== $reference = XmlUtil::getValueFromXPath('@property-ref', $xpath, $fieldNode)) {
  295.             $nodeList = $xpath->query(\sprintf('/x:list/x:properties/x:*[@name="%s"]', $reference));
  297.             if (0 === $nodeList->length) {
  298.                 throw new \Exception(\sprintf('Rest metadata doctrine field reference "%s" was not found.', $reference));
  299.             }
  301.             return $this->getField($xpath, $nodeList->item(0));
  302.         }
  304.         if (null === ($fieldName = XmlUtil::getValueFromXPath('x:field-name', $xpath, $fieldNode))
  305.             || null === ($entityName = XmlUtil::getValueFromXPath('x:entity-name', $xpath, $fieldNode))
  306.         ) {
  307.             return;
  308.         }
  310.         $field = new FieldMetadata($this->resolveParameter($fieldName), $this->resolveParameter($entityName));
  312.         $joinsNodeList = $xpath->query('x:joins', $fieldNode);
  313.         if ($joinsNodeList->length > 0) {
  314.             $this->getJoinsMetadata($xpath, $joinsNodeList->item(0), $field);
  315.         }
  317.         return $field;
  318.     }
  320.     private function getJoinsMetadata(\DOMXPath $xpath, \DOMElement $joinsNode, FieldMetadata $field)
  321.     {
  322.         if (null !== $reference = XmlUtil::getValueFromXPath('@ref', $xpath, $joinsNode)) {
  323.             $nodeList = $xpath->query(\sprintf('/x:list/x:joins[@name="%s"]', $reference));
  325.             if (0 === $nodeList->length) {
  326.                 throw new \Exception(\sprintf('Rest metadata doctrine joins reference "%s" was not found.', $reference));
  327.             }
  329.             $this->getJoinsMetadata($xpath, $nodeList->item(0), $field);
  330.         }
  332.         foreach ($xpath->query('x:join', $joinsNode) as $joinNode) {
  333.             $field->addJoin($this->getJoinMetadata($xpath, $joinNode));
  334.         }
  335.     }
  337.     protected function getJoinMetadata(\DOMXPath $xpath, \DOMElement $joinNode)
  338.     {
  339.         $joinMetadata = new JoinMetadata();
  341.         if (null !== $fieldName = XmlUtil::getValueFromXPath('x:field-name', $xpath, $joinNode)) {
  342.             $joinMetadata->setEntityField($this->resolveParameter($fieldName));
  343.         }
  345.         if (null !== $entityName = XmlUtil::getValueFromXPath('x:entity-name', $xpath, $joinNode)) {
  346.             $joinMetadata->setEntityName($this->resolveParameter($entityName));
  347.         }
  349.         if (null !== $condition = XmlUtil::getValueFromXPath('x:condition', $xpath, $joinNode)) {
  350.             $joinMetadata->setCondition($this->resolveParameter($condition));
  351.         }
  353.         if (null !== $conditionMethod = XmlUtil::getValueFromXPath('x:condition-method', $xpath, $joinNode)) {
  354.             /** @var 'ON'|'WITH' $conditionMethod */
  355.             $joinMetadata->setConditionMethod($this->resolveParameter($conditionMethod));
  356.         }
  358.         if (null !== $method = XmlUtil::getValueFromXPath('x:method', $xpath, $joinNode)) {
  359.             /** @var 'LEFT'|'INNER'|'RIGHT' $method */
  360.             $joinMetadata->setMethod($method);
  361.         }
  363.         return $joinMetadata;
  364.     }
  366.     private function resolveParameter($value)
  367.     {
  368.         return $this->parameterBag->resolveValue($value);
  369.     }
  370. }