/**
* @param array $serializedObject
*
* @return mixed
*
* @throws SerializationException
*/
public function deserialize(array $serializedObject)
{
Assert::keyExists($serializedObject, 'type', "Key 'type' should be set.");
Assert::keyExists($serializedObject, 'payload', "Key 'payload' should be set.");
// TODO implement TypeDenormalizer
return $this->denormalizer->denormalize($serializedObject['payload'], $serializedObject['type'], 'json');
}
/**
* @test
*/
public function it_deserializes_objects_by_passing_then_to_the_denormalizer()
{
$data = array('type' => 'aFlyingDuck', 'payload' => array('duck_name' => 'bob'));
$result = new \stdClass();
$this->denormalizerMock->expects(self::atLeastOnce())->method('denormalize')->with(array('duck_name' => 'bob'), 'aFlyingDuck', 'json')->willReturn($result);
self::assertSame($result, $this->serializer->deserialize($data));
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = array())
{
$productValues = [];
foreach ($data as $attFieldName => $dataValue) {
$attributeInfos = $this->fieldNameBuilder->extractAttributeFieldNameInfos($attFieldName);
if (null !== $attributeInfos) {
$attribute = $attributeInfos['attribute'];
unset($attributeInfos['attribute']);
$valueKey = $attribute->getCode();
if ($attribute->isLocalizable()) {
$valueKey .= '-' . $attributeInfos['locale_code'];
}
if ($attribute->isScopable()) {
$valueKey .= '-' . $attributeInfos['scope_code'];
}
if (isset($productValues[$valueKey])) {
$value = $productValues[$valueKey];
} else {
$value = new $this->valueClass();
$value->setAttribute($attribute);
$value->setLocale($attributeInfos['locale_code']);
$value->setScope($attributeInfos['scope_code']);
}
$productValues[$valueKey] = $this->valueDenormalizer->denormalize($dataValue, $this->valueClass, 'csv', ['entity' => $value] + $attributeInfos);
}
}
return new ArrayCollection($productValues);
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
$data = $this->valuesDenormalizer->denormalize($data, $class, $format, $context);
if (null !== $data) {
$data = $this->localizer->localize($data, $context);
}
return $data;
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
$metric = $this->metricDenormalizer->denormalize($data, $class, $format, $context);
if (null !== $metric) {
$metric->setData($this->localizer->localize($metric->getData(), $context));
}
return $metric;
}
/**
* @param FormEvent $event
*/
public function preSetData(FormEvent $event)
{
$data = $event->getData();
if (null === $data || !$data instanceof ProductTemplateInterface) {
return;
}
$values = $this->denormalizer->denormalize($data->getValuesData(), 'ProductValue[]', 'json', ['locale' => $this->localeResolver->getCurrentLocale(), 'disable_grouping_separator' => true]);
$data->setValues($values);
}
/**
* @param FormEvent $event
*/
public function preSetData(FormEvent $event)
{
$data = $event->getData();
if (null === $data || !$data instanceof ProductTemplateInterface) {
return;
}
$values = $this->denormalizer->denormalize($data->getValuesData(), 'ProductValue[]', 'json');
$data->setValues($values);
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
$prices = $this->priceDenormalizer->denormalize($data, $class, $format, $context);
if (null !== $prices) {
foreach ($prices as $price) {
$price->setData($this->localizer->localize($price->getData(), $context));
}
}
return $prices;
}
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
{
if (isset($data['domains'])) {
foreach ($data['domains'] as $value) {
$domain = $denormalizer->denormalize($value, __NAMESPACE__ . '\\' . 'Domain');
$this->addDomain($domain);
}
unset($data['domains']);
}
return parent::denormalize($denormalizer, $data, $format);
}
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
{
if (isset($data['mailboxes'])) {
foreach ($data['mailboxes'] as $value) {
$mailbox = $denormalizer->denormalize($value, __NAMESPACE__ . '\\' . 'Mailbox');
$this->addMailbox($mailbox);
}
unset($data['mailboxes']);
}
return parent::denormalize($denormalizer, $data, $format);
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
$values = new ArrayCollection();
foreach ($data as $attributeCode => $valuesData) {
$attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
foreach ($valuesData as $valueData) {
$value = $this->denormalizer->denormalize($valueData, $this->valueClass, 'json', ['attribute' => $attribute] + $context);
$values->add($value);
}
}
return $values;
}
/**
* Build product values from template values raw data
*
* @param ProductTemplateInterface $template
* @param AttributeInterface[] $attributes
*
* @return ProductValueInterface[]
*/
protected function buildProductValuesFromTemplateValuesData(ProductTemplateInterface $template, array $attributes)
{
$values = $this->denormalizer->denormalize($template->getValuesData(), 'ProductValue[]', 'json');
$product = new $this->productClass();
foreach ($values as $value) {
$product->addValue($value);
}
foreach ($attributes as $attribute) {
$this->productBuilder->addAttributeToProduct($product, $attribute);
}
return $product->getValues();
}
/**
* Build product values from template values raw data
*
* @param ProductTemplateInterface $template
* @param AttributeInterface[] $attributes
* @param string $locale
*
* @return ProductValueInterface[]
*/
protected function buildProductValuesFromTemplateValuesData(ProductTemplateInterface $template, array $attributes, $locale)
{
$options = ['locale' => $locale, 'disable_grouping_separator' => true];
$values = $this->denormalizer->denormalize($template->getValuesData(), 'ProductValue[]', 'json', $options);
$product = new $this->productClass();
foreach ($values as $value) {
$product->addValue($value);
}
foreach ($attributes as $attribute) {
$this->productBuilder->addAttributeToProduct($product, $attribute);
}
$this->productBuilder->addMissingProductValues($product);
return $product->getValues();
}
/**
* @param mixed $data
* @param string $class
* @param mixed $format
* @param array $context
* @return AbstractTypedAddress
*/
public function denormalize($data, $class, $format = null, array $context = array())
{
/** @var AbstractTypedAddress $result */
$result = $this->addressNormalizer->denormalize($data, $class, $format, $context);
if (!empty($data['types']) && is_array($data['types'])) {
$types = $this->serializer->denormalize($data['types'], static::TYPES_TYPE, $format, $context);
if ($types) {
foreach ($types as $type) {
$result->addType($type);
}
}
}
return $result;
}
/**
* Returns collection of denormalized data
*
* @param mixed $data
* @param string $class
* @param mixed $format
* @param array $context
* @return ArrayCollection
*/
public function denormalize($data, $class, $format = null, array $context = array())
{
if (!is_array($data)) {
return new ArrayCollection();
}
$itemType = $this->getItemType($class);
if (!$itemType) {
return new ArrayCollection($data);
}
$result = new ArrayCollection();
foreach ($data as $item) {
$result->add($this->serializer->denormalize($item, $itemType, $format, $context));
}
return $result;
}
/**
* @param array $values
* @param string $class
* @param string $format
* @param array $context
*
* @return array|object
*/
public function denormalize($values, $class, $format = null, array $context = array())
{
if (!is_array($values)) {
return $values;
}
$filtered = array_filter($values, function ($value) use($class, $format) {
return $this->serializer->supportsDenormalization($value, $class, $format);
});
if (count($filtered) !== count($values)) {
throw new \InvalidArgumentException('Not all values within the array can be denormalized.');
}
return array_map(function ($value) use($class, $format, $context) {
return $this->serializer->denormalize($value, $class, $format, $context);
}, $filtered);
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
if (isset($data['#type'])) {
$type = $data['#type'];
unset($data['#type']);
$data = $this->denormalize($data, $type, $format, $context);
$data = $this->objectNormalizer->denormalize($data, $type, $format, $context);
return $data;
}
if (is_array($data) || $data instanceof \Traversable) {
foreach ($data as $key => $value) {
$data[$key] = $this->serializer->denormalize($value, $class, $format, $context);
}
}
return $data;
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $referenceDataClass, $format = null, array $context = [])
{
if (empty($data)) {
return new ArrayCollection();
}
if (false === is_array($data)) {
throw new InvalidParameterException(sprintf('Data expected to be an array.'));
}
$referenceDataColl = new ArrayCollection();
foreach ($data as $singleData) {
$referenceData = $this->referenceDataDenormalizer->denormalize($singleData, $referenceDataClass, $format, $context);
if (null !== $referenceData) {
$referenceDataColl->add($referenceData);
}
}
return $referenceDataColl;
}
/**
* Normalizes and returns the media values of a product template
*
* @param ProductTemplateInterface|null $template
*
* @return \Pim\Bundle\CatalogBundle\Model\ProductValueInterface[]
*/
protected function getProductTemplateMediaValues(ProductTemplateInterface $template = null)
{
if (null === $template) {
return [];
}
$values = $this->denormalizer->denormalize($template->getValuesData(), 'ProductValue[]', 'json');
return $values->filter(function ($value) {
return in_array($value->getAttribute()->getAttributeType(), [AttributeTypes::IMAGE, AttributeTypes::FILE]);
})->toArray();
}
/**
* Normalize the variant group values
*
* @param GroupInterface $group
* @param string $format
* @param array $context
*
* @return array
*/
protected function normalizeVariantGroupValues(GroupInterface $group, $format, array $context)
{
if (!$group->getType()->isVariant() || null === $group->getProductTemplate()) {
return [];
}
$context["entity"] = "variant-group";
// As variant group > product template > values data are not type hinted we cannot normalize them directly
// so we first denormalize them into product values using the common format then normalize them
// this allow to transform localization based values for example
return $this->valuesNormalizer->normalize($this->valuesDenormalizer->denormalize($group->getProductTemplate()->getValuesData(), $format, $context), $format, $context);
}
/**
* Filter empty values that are not used in a template then denormalize the product values objects from CSV fields
*
* @param array $rawProductValues
* @param ProductTemplateInterface $template
*
* @return ProductValueInterface[]
*/
protected function denormalizeValuesFromItemData(array $rawProductValues, ProductTemplateInterface $template = null)
{
$templateCodes = null !== $template ? array_keys($template->getValuesData()) : [];
foreach ($rawProductValues as $index => $data) {
$attributeInfos = $this->fieldNameBuilder->extractAttributeFieldNameInfos($index);
$attribute = $attributeInfos['attribute'];
if ("" === trim($data) && !in_array($attribute->getCode(), $templateCodes)) {
unset($rawProductValues[$index]);
}
}
return $this->denormalizer->denormalize($rawProductValues, 'ProductValue[]', 'csv');
}
public function testDenormalizationWithType()
{
$dummy = $this->getDummy();
$this->normalizer->addType('dummy', TypehintNormalizerClassDummy::class);
$this->normalizer->addType('subdummy', TypehintNormalizerSubclassDummy::class);
$expected = $dummy;
$normalized = $this->normalizer->normalize($dummy);
$this->assertTrue($this->normalizer->supportsDenormalization($normalized, RecursiveNormalizerClassDummy::class));
$actual = $this->normalizer->denormalize($normalized, TypehintNormalizerClassDummy::class);
$this->assertEquals($expected, $actual);
}
/**
* Update the variant group fields
*
* @param GroupInterface $group
* @param array $groupData
*
* @return GroupInterface
*/
protected function updateGroup(GroupInterface $group, array $groupData)
{
$group = $this->denormalizer->denormalize($groupData, $this->class, $this->format, ['entity' => $group]);
return $group;
}
/**
* {@inheritdoc}
*/
public function handleGetRequest(Request $request, $identifier)
{
$resource = $this->getResourceById($identifier);
$data = $this->serializer->serialize($resource, self::RESPONSE_FORMAT, ['group' => $this->getResourceType()]);
return new Response($data);
}
/**
* {@inheritdoc}
*/
public function supportsDenormalization($data, $type, $format = null)
{
return substr($type, -2) === '[]' && $this->serializer->supportsDenormalization($data, substr($type, 0, -2), $format);
}
