vendor/sulu/sulu/src/Sulu/Component/Localization/Localization.php line 21

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of Sulu.
  4.  *
  5.  * (c) Sulu GmbH
  6.  *
  7.  * This source file is subject to the MIT license that is bundled
  8.  * with this source code in the file LICENSE.
  9.  */
  10. namespace Sulu\Component\Localization;
  11. use JMS\Serializer\Annotation\Groups;
  12. use JMS\Serializer\Annotation\VirtualProperty;
  13. use Sulu\Component\Util\ArrayableInterface;
  14. /**
  15.  * Represents a localization of a webspace definition.
  16.  */
  17. class Localization implements \JsonSerializableArrayableInterface
  18. {
  19.     const UNDERSCORE 'de_at';
  20.     const DASH 'de-at';
  21.     const ISO6391 'de-AT';
  22.     const LCID 'de_AT';
  23.     /**
  24.      * Create an instance of localization for given locale.
  25.      *
  26.      * @param string $locale
  27.      * @param string $format
  28.      *
  29.      * @return Localization
  30.      */
  31.     public static function createFromString($locale$format self::UNDERSCORE)
  32.     {
  33.         $delimiter '-';
  34.         if (in_array($format, [self::UNDERSCOREself::LCID])) {
  35.             $delimiter '_';
  36.         }
  37.         $parts explode($delimiter$locale);
  38.         $localization = new self();
  39.         $localization->setLanguage(strtolower($parts[0]));
  40.         if (count($parts) > 1) {
  41.             $localization->setCountry(strtolower($parts[1]));
  42.         }
  43.         return $localization;
  44.     }
  45.     /**
  46.      * The language of the localization.
  47.      *
  48.      * @var string
  49.      * @Groups({"frontend", "Default"})
  50.      */
  51.     private $language;
  52.     /**
  53.      * The country of the localization.
  54.      *
  55.      * @var string
  56.      * @Groups({"frontend", "Default"})
  57.      */
  58.     private $country;
  59.     /**
  60.      * Defines how the generation of shadow pages should be handled.
  61.      *
  62.      * @var string
  63.      * @Groups({"frontend", "Default"})
  64.      */
  65.     private $shadow;
  66.     /**
  67.      * The sub localizations of this one.
  68.      *
  69.      * @var Localization[]
  70.      * @Groups({"frontend", "Default"})
  71.      */
  72.     private $children;
  73.     /**
  74.      * The parent localization.
  75.      *
  76.      * @var Localization
  77.      * @Groups({"frontend", "Default"})
  78.      */
  79.     private $parent;
  80.     /**
  81.      * Defines whether this localization is the default one or not.
  82.      *
  83.      * @var bool
  84.      * @Groups({"frontend", "Default"})
  85.      */
  86.     private $default;
  87.     /**
  88.      * Defines whether this localization is the x-default one or not.
  89.      * This will be used to determine the default hreflang tag.
  90.      *
  91.      * @var bool
  92.      * @Groups({"frontend", "Default"})
  93.      */
  94.     private $xDefault;
  95.     public function __construct($language null$country null)
  96.     {
  97.         $this->language $language;
  98.         $this->country $country;
  99.     }
  100.     /**
  101.      * Sets the country of this localization.
  102.      *
  103.      * @param string $country
  104.      */
  105.     public function setCountry($country)
  106.     {
  107.         $this->country $country;
  108.     }
  109.     /**
  110.      * Returns the country of this localization.
  111.      *
  112.      * @return string
  113.      */
  114.     public function getCountry()
  115.     {
  116.         return $this->country;
  117.     }
  118.     /**
  119.      * Sets the language of this localization.
  120.      *
  121.      * @param string $language
  122.      */
  123.     public function setLanguage($language)
  124.     {
  125.         $this->language $language;
  126.     }
  127.     /**
  128.      * Returns the language of this localization.
  129.      *
  130.      * @return string
  131.      */
  132.     public function getLanguage()
  133.     {
  134.         return $this->language;
  135.     }
  136.     /**
  137.      * Sets how to handle shadow pages for this localization.
  138.      *
  139.      * @param string $shadow
  140.      */
  141.     public function setShadow($shadow)
  142.     {
  143.         $this->shadow $shadow;
  144.     }
  145.     /**
  146.      * Returns how to handle shadow pages for this localization.
  147.      *
  148.      * @return string
  149.      */
  150.     public function getShadow()
  151.     {
  152.         return $this->shadow;
  153.     }
  154.     /**
  155.      * Adds a new child localization.
  156.      *
  157.      * @param Localization $child
  158.      */
  159.     public function addChild(self $child)
  160.     {
  161.         $this->children[] = $child;
  162.     }
  163.     /**
  164.      * Sets the children of the localization.
  165.      *
  166.      * @param Localization[] $children
  167.      */
  168.     public function setChildren($children)
  169.     {
  170.         $this->children $children;
  171.     }
  172.     /**
  173.      * Returns the children of the localization.
  174.      *
  175.      * @return Localization[]
  176.      */
  177.     public function getChildren()
  178.     {
  179.         return $this->children;
  180.     }
  181.     /**
  182.      * Returns the localization code, which is a combination of the language and the country.
  183.      *
  184.      * @param string $delimiter between language and country
  185.      *
  186.      * @return string
  187.      * @VirtualProperty
  188.      * @Groups({"frontend", "Default"})
  189.      *
  190.      * @deprecated use getLocale instead
  191.      */
  192.     public function getLocalization($delimiter '_')
  193.     {
  194.         @trigger_error(__METHOD__ '() is deprecated since version 1.2 and will be removed in 2.0. Use getLocale() instead.'E_USER_DEPRECATED);
  195.         $localization $this->getLanguage();
  196.         if (null != $this->getCountry()) {
  197.             $localization .= $delimiter $this->getCountry();
  198.         }
  199.         return $localization;
  200.     }
  201.     /**
  202.      * Returns the localization code, which is a combination of the language and the country in a specific format.
  203.      *
  204.      * @param string $format requested localization format
  205.      *
  206.      * @return string
  207.      * @VirtualProperty
  208.      * @Groups({"frontend", "Default"})
  209.      */
  210.     public function getLocale($format self::UNDERSCORE)
  211.     {
  212.         $localization strtolower($this->getLanguage());
  213.         if (null != $this->getCountry()) {
  214.             $country strtolower($this->getCountry());
  215.             $delimiter '-';
  216.             switch ($format) {
  217.                 case self::UNDERSCORE:
  218.                     $delimiter '_';
  219.                     break;
  220.                 case self::ISO6391:
  221.                     $country strtoupper($country);
  222.                     break;
  223.                 case self::LCID:
  224.                     $delimiter '_';
  225.                     $country strtoupper($country);
  226.                     break;
  227.             }
  228.             $localization .= $delimiter $country;
  229.         }
  230.         return $localization;
  231.     }
  232.     /**
  233.      * Sets the parent of this localization.
  234.      *
  235.      * @param Localization $parent
  236.      */
  237.     public function setParent(self $parent)
  238.     {
  239.         $this->parent $parent;
  240.     }
  241.     /**
  242.      * Returns the parent of this localization.
  243.      *
  244.      * @return Localization
  245.      */
  246.     public function getParent()
  247.     {
  248.         return $this->parent;
  249.     }
  250.     /**
  251.      * Sets if this localization is the default one.
  252.      *
  253.      * @param bool $default
  254.      */
  255.     public function setDefault($default)
  256.     {
  257.         $this->default $default;
  258.     }
  259.     /**
  260.      * Sets if this localization is the x-default one.
  261.      *
  262.      * @param bool $xDefault
  263.      */
  264.     public function setXDefault($xDefault)
  265.     {
  266.         $this->xDefault $xDefault;
  267.     }
  268.     /**
  269.      * Returns if this localization is the default one.
  270.      *
  271.      * @return bool True if this is the default localization, otherwise false
  272.      */
  273.     public function isDefault()
  274.     {
  275.         return $this->default;
  276.     }
  277.     /**
  278.      * Returns if this localization is the x-default one.
  279.      *
  280.      * @return bool True if this is the x-default localization, otherwise false
  281.      */
  282.     public function isXDefault()
  283.     {
  284.         return $this->xDefault;
  285.     }
  286.     /**
  287.      * @param string $localization
  288.      *
  289.      * @return Localization|null
  290.      */
  291.     public function findLocalization($localization)
  292.     {
  293.         if ($this->getLocale() == $localization) {
  294.             return $this;
  295.         }
  296.         $children $this->getChildren();
  297.         if (!empty($children)) {
  298.             foreach ($children as $childLocalization) {
  299.                 $result $childLocalization->findLocalization($localization);
  300.                 if ($result) {
  301.                     return $result;
  302.                 }
  303.             }
  304.         }
  305.         return;
  306.     }
  307.     /**
  308.      * Returns a list of all localizations and sublocalizations.
  309.      *
  310.      * @return Localization[]
  311.      */
  312.     public function getAllLocalizations()
  313.     {
  314.         $localizations = [];
  315.         if (null !== $this->getChildren() && count($this->getChildren()) > 0) {
  316.             foreach ($this->getChildren() as $child) {
  317.                 $localizations[] = $child;
  318.                 $localizations array_merge($localizations$child->getAllLocalizations());
  319.             }
  320.         }
  321.         return $localizations;
  322.     }
  323.     /**
  324.      * @return string
  325.      */
  326.     public function __toString()
  327.     {
  328.         return $this->getLocale();
  329.     }
  330.     public function jsonSerialize()
  331.     {
  332.         return [
  333.             'localization' => $this->getLocale(),
  334.             'name' => $this->getLocale(),
  335.         ];
  336.     }
  337.     public function toArray($depth null)
  338.     {
  339.         $res = [];
  340.         $res['country'] = $this->getCountry();
  341.         $res['language'] = $this->getLanguage();
  342.         $res['localization'] = $this->getLocale();
  343.         $res['default'] = $this->isDefault();
  344.         $res['xDefault'] = $this->isXDefault();
  345.         $res['children'] = [];
  346.         $children $this->getChildren();
  347.         if ($children) {
  348.             foreach ($this->getChildren() as $childLocalization) {
  349.                 $res['children'][] = $childLocalization->toArray(null);
  350.             }
  351.         }
  352.         $res['shadow'] = $this->getShadow();
  353.         return $res;
  354.     }
  355. }