PHP AttributeInterface::isLocalizable方法代碼示例

 /**
  * Normalize the field name from attribute and catalog context
  *
  * @param AttributeInterface $attribute
  * @param string             $locale
  * @param string             $scope
  *
  * @return string
  */
 public static function getNormalizedValueFieldFromAttribute(AttributeInterface $attribute, $locale = null, $scope = null)
 {
     if ($attribute->isLocalizable() && null === $locale) {
         throw new \LogicException('Locale is not configured');
     }
     if ($attribute->isScopable() && null === $scope) {
         throw new \LogicException('Scope is not configured');
     }
     return self::getNormalizedValueField($attribute->getCode(), $attribute->isLocalizable(), $attribute->isScopable(), $attribute->isLocalizable() ? $locale : null, $attribute->isScopable() ? $scope : null);
 }

 function it_resolves_eligible_values_for_a_set_of_attributes($localeRepository, $channelRepository, AttributeInterface $sku, AttributeInterface $name, AttributeInterface $desc, AttributeInterface $tax, LocaleInterface $fr, LocaleInterface $en, ChannelInterface $ecom, ChannelInterface $print)
 {
     $sku->getCode()->willReturn('sku');
     $sku->getAttributeType()->willReturn('pim_catalog_identifier');
     $sku->isLocalizable()->willReturn(false);
     $sku->isScopable()->willReturn(false);
     $sku->isLocaleSpecific()->willReturn(false);
     $name->getCode()->willReturn('name');
     $name->getAttributeType()->willReturn('pim_catalog_text');
     $name->isLocalizable()->willReturn(true);
     $name->isScopable()->willReturn(false);
     $name->isLocaleSpecific()->willReturn(false);
     $desc->getCode()->willReturn('description');
     $desc->getAttributeType()->willReturn('pim_catalog_text');
     $desc->isLocalizable()->willReturn(true);
     $desc->isScopable()->willReturn(true);
     $desc->isLocaleSpecific()->willReturn(false);
     $tax->getCode()->willReturn('tax');
     $tax->getAttributeType()->willReturn('pim_catalog_text');
     $tax->isLocalizable()->willReturn(true);
     $tax->isScopable()->willReturn(false);
     $tax->isLocaleSpecific()->willReturn(true);
     $tax->getLocaleSpecificCodes()->willReturn(['fr_FR']);
     $fr->getCode()->willReturn('fr_FR');
     $en->getCode()->willReturn('en_US');
     $localeRepository->getActivatedLocales()->willReturn([$fr, $en]);
     $ecom->getCode()->willReturn('ecommerce');
     $ecom->getLocales()->willReturn([$en, $fr]);
     $print->getCode()->willReturn('print');
     $print->getLocales()->willReturn([$en, $fr]);
     $channelRepository->findAll()->willReturn([$ecom, $print]);
     $this->resolveEligibleValues([$sku, $name, $desc, $tax])->shouldReturn([['attribute' => 'sku', 'type' => 'pim_catalog_identifier', 'locale' => null, 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => null], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'print'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'print'], ['attribute' => 'tax', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => null]]);
 }

 function it_throws_exception_when_scope_is_not_provided_but_expected(ProductInterface $product, AttributeInterface $price)
 {
     $price->getCode()->willReturn('price');
     $price->isLocalizable()->willReturn(false);
     $price->isScopable()->willReturn(true);
     $this->shouldThrow(new \InvalidArgumentException('A scope must be provided to create a value for the scopable attribute price'))->duringAddProductValue($product, $price);
 }

 /**
  * Sets the attribute
  *
  * @param AttributeInterface $attribute
  *
  * @throws ColumnLabelException
  */
 public function setAttribute(AttributeInterface $attribute = null)
 {
     $this->attribute = $attribute;
     if (null === $attribute) {
         $this->locale = null;
         $this->scope = null;
         $this->suffixes = $this->rawSuffixes;
         $this->propertyPath = lcfirst(Inflector::classify($this->name));
     } else {
         if (!in_array($attribute->getBackendType(), [AbstractAttributeType::BACKEND_TYPE_REF_DATA_OPTION, AbstractAttributeType::BACKEND_TYPE_REF_DATA_OPTIONS])) {
             $this->propertyPath = $attribute->getBackendType();
         } else {
             $this->propertyPath = $attribute->getReferenceDataName();
         }
         $suffixes = $this->rawSuffixes;
         if ($attribute->isLocalizable()) {
             if (count($suffixes)) {
                 $this->locale = array_shift($suffixes);
             } else {
                 throw new ColumnLabelException('The column "%column%" must contain a locale code', ['%column%' => $this->label]);
             }
         }
         if ($attribute->isScopable()) {
             if (count($suffixes)) {
                 $this->scope = array_shift($suffixes);
             } else {
                 throw new ColumnLabelException('The column "%column%" must contain a scope code', ['%column%' => $this->label]);
             }
         }
         $this->suffixes = $suffixes;
     }
 }

 /**
  * Sets the attribute
  *
  * @param AttributeInterface $attribute
  *
  * @throws ColumnLabelException
  */
 public function setAttribute(AttributeInterface $attribute = null)
 {
     $this->attribute = $attribute;
     if (null === $attribute) {
         $this->locale = null;
         $this->scope = null;
         $this->suffixes = $this->rawSuffixes;
         $this->propertyPath = lcfirst(Inflector::classify($this->name));
     } else {
         $this->propertyPath = $attribute->getBackendType();
         $suffixes = $this->rawSuffixes;
         if ($attribute->isLocalizable()) {
             if (count($suffixes)) {
                 $this->locale = array_shift($suffixes);
             } else {
                 throw new ColumnLabelException('The column "%column%" must contain a locale code', array('%column%' => $this->label));
             }
         }
         if ($attribute->isScopable()) {
             if (count($suffixes)) {
                 $this->scope = array_shift($suffixes);
             } else {
                 throw new ColumnLabelException('The column "%column%" must contain a scope code', array('%column%' => $this->label));
             }
         }
         $this->suffixes = $suffixes;
     }
 }

 function let(SerializerInterface $serializer, AttributeInterface $simpleAttribute)
 {
     $serializer->implement('Symfony\\Component\\Serializer\\Normalizer\\NormalizerInterface');
     $this->setSerializer($serializer);
     $simpleAttribute->isLocalizable()->willReturn(false);
     $simpleAttribute->isScopable()->willReturn(false);
     $simpleAttribute->getCode()->willReturn('simple');
 }

 function it_throws_an_exception_when_the_scope_is_not_provided(AttributeInterface $price)
 {
     $price->getId()->willReturn(42);
     $price->isLocalizable()->willReturn(false);
     $price->isScopable()->willReturn(true);
     $price->getCode()->willReturn('price');
     $this->shouldThrow('\\InvalidArgumentException')->duringPrepareCondition($price, 'alias', 'en_US', null);
 }

 /**
  * Prepare join to attribute condition with current locale and scope criterias
  *
  * @param AttributeInterface $attribute the attribute
  * @param string             $joinAlias the value join alias
  * @param string             $locale    the locale
  * @param string             $scope     the scope
  *
  * @return string
  */
 public function prepareCondition(AttributeInterface $attribute, $joinAlias, $locale = null, $scope = null)
 {
     $condition = $joinAlias . '.attribute = ' . $attribute->getId();
     if ($attribute->isLocalizable() && null === $locale) {
         throw new \InvalidArgumentException(sprintf('Cannot prepare condition on localizable attribute "%s" without locale', $attribute->getCode()));
     }
     if ($attribute->isLocalizable()) {
         $condition .= ' AND ' . $joinAlias . '.locale = ' . $this->qb->expr()->literal($locale);
     }
     if ($attribute->isScopable() && null === $scope) {
         throw new \InvalidArgumentException(sprintf('Cannot prepare condition on scopable attribute "%s" without scope', $attribute->getCode()));
     }
     if ($attribute->isScopable()) {
         $condition .= ' AND ' . $joinAlias . '.scope = ' . $this->qb->expr()->literal($scope);
     }
     return $condition;
 }

 function let(Builder $qb, AttributeInterface $image, AttributeValidatorHelper $attrValidatorHelper)
 {
     $this->beConstructedWith($attrValidatorHelper, ['pim_catalog_image', 'pim_catalog_file'], ['STARTS WITH', 'ENDS WITH', 'CONTAINS', 'DOES NOT CONTAIN', '=', 'EMPTY']);
     $this->setQueryBuilder($qb);
     $image->getCode()->willReturn('picture');
     $image->isLocalizable()->willReturn(false);
     $image->isScopable()->willReturn(false);
 }

 /**
  * Check if locale data is consistent with the attribute localizable property
  *
  * @param AttributeInterface $attribute
  * @param string             $locale
  *
  * @throws \LogicException
  */
 public function validateLocale(AttributeInterface $attribute, $locale)
 {
     if (!$attribute->isLocalizable() && null === $locale) {
         return;
     }
     if ($attribute->isLocalizable() && null === $locale) {
         throw new \LogicException(sprintf('Attribute "%s" expects a locale, none given.', $attribute->getCode()));
     }
     if (!$attribute->isLocalizable() && null !== $locale) {
         throw new \LogicException(sprintf('Attribute "%s" does not expect a locale, "%s" given.', $attribute->getCode(), $locale));
     }
     if (null === static::$localeCodes) {
         static::$localeCodes = $this->getActivatedLocaleCodes();
     }
     if (!in_array($locale, static::$localeCodes)) {
         throw new \LogicException(sprintf('Attribute "%s" expects an existing and activated locale, "%s" given.', $attribute->getCode(), $locale));
     }
 }

 function it_adds_a_order_by_on_an_attribute_value_in_the_query(Builder $queryBuilder, AttributeInterface $sku)
 {
     $sku->getCode()->willReturn('sku');
     $sku->isLocalizable()->willReturn(false);
     $sku->isScopable()->willReturn(false);
     $queryBuilder->sort('normalizedData.sku', 'desc')->willReturn($queryBuilder);
     $queryBuilder->sort('_id')->shouldBeCalled();
     $this->addAttributeSorter($sku, 'desc');
 }

 /**
  * Get all locale codes
  * @param AttributeInterface $attribute
  *
  * @return array
  */
 public function getLocaleCodes(AttributeInterface $attribute = null)
 {
     $localeCodes = [];
     if (null === $attribute || $attribute->isLocalizable()) {
         foreach ($this->getLocales() as $locale) {
             $localeCodes[] = $locale->getCode();
         }
     }
     return $localeCodes;
 }

 function it_throws_an_exception_when_scope_is_expected_but_not_existing($attrValidatorHelper, AttributeInterface $attribute)
 {
     $e = new \LogicException('Attribute "attributeCode" expects an existing scope, "ecommerce" given.');
     $attribute->getCode()->willReturn('attributeCode');
     $attribute->isLocalizable()->willReturn(false);
     $attribute->isScopable()->willReturn(true);
     $attrValidatorHelper->validateLocale($attribute, null)->shouldBeCalled();
     $attrValidatorHelper->validateScope($attribute, 'ecommerce')->willThrow($e);
     $this->shouldThrow(InvalidArgumentException::expectedFromPreviousException($e, 'attributeCode', 'setter', 'concrete'))->during('testLocaleAndScope', [$attribute, null, 'ecommerce']);
 }

 function it_normalizes_value_with_decimal_support_backend(ProductValueInterface $value, AttributeInterface $attribute)
 {
     $attribute->getCode()->willReturn('code');
     $attribute->getBackendType()->willReturn('decimal');
     $attribute->isLocalizable()->willReturn(false);
     $attribute->isScopable()->willReturn(false);
     $value->getData()->willReturn('42.42');
     $value->getAttribute()->willReturn($attribute);
     $this->normalize($value, 'mongodb_json', [])->shouldReturn(['code' => 42.42]);
 }

 function it_does_not_throw_an_exception_when_scopable_requirement_is_respected(AttributeInterface $description, AttributeInterface $name)
 {
     $description->isLocalizable()->willReturn(true);
     $description->isScopable()->willReturn(true);
     $description->getCode()->willReturn('description');
     $name->isLocalizable()->willReturn(false);
     $name->isScopable()->willReturn(false);
     $name->getCode()->willReturn('name');
     $this->validateScope($description, 'ecommerce');
     $this->validateScope($name, null);
 }