public function testNormalize()
{
$obj = new GetSetDummy();
$object = new \stdClass();
$obj->setFoo('foo');
$obj->setBar('bar');
$obj->setBaz(true);
$obj->setCamelCase('camelcase');
$obj->setObject($object);
$this->serializer
->expects($this->once())
->method('normalize')
->with($object, 'any')
->will($this->returnValue('string_object'))
;
$this->assertEquals(
array(
'foo' => 'foo',
'bar' => 'bar',
'baz' => true,
'fooBar' => 'foobar',
'camelCase' => 'camelcase',
'object' => 'string_object',
),
$this->normalizer->normalize($obj, 'any')
);
}
/**
* {@inheritdoc}
*/
public function collect(RequestObject $requestObject, array $parameters = [])
{
$parameters = $this->resolveCollectorParameters($parameters);
$logFile = sprintf('%s/%s.%s', $this->logFolder, $this->kernelEnvironment, $parameters['logFile']);
$this->logger->pushHandler(new StreamHandler($logFile));
$this->logger->info('request_collector.collect', $this->serializer->normalize($requestObject));
}
/**
* Normalize a decimal attribute value
*
* @param mixed $data
* @param string $format
* @param array $context
*
* @return mixed|null
*/
protected function normalizeDecimal($data, $format, $context)
{
if (false === is_numeric($data)) {
return $this->serializer->normalize($data, $format, $context);
}
return floatval($data);
}
/**
* Create a new item.
*
* @param Request $request
* @param string|int $id
*
* @throws NotFoundHttpException
* @throws RuntimeException
* @throws UserProtectedException
* @throws UserLimitReachedException
*
* @return mixed
*/
public function __invoke(Request $request, $id)
{
/**
* @var $resourceType ResourceInterface
*/
list($resourceType, $format) = $this->extractAttributes($request);
/*
* Workaround to ensure stockLevels are not overwritten in a PUT request.
* @see https://github.com/partkeepr/PartKeepr/issues/551
*/
$data = json_decode($request->getContent(), true);
if (array_key_exists('stockLevels', $data)) {
unset($data['stockLevels']);
}
$requestData = json_encode($data);
$data = $this->getItem($this->dataProvider, $resourceType, $id);
$context = $resourceType->getDenormalizationContext();
$context['object_to_populate'] = $data;
/**
* @var $part Part
*/
$part = $this->serializer->deserialize($requestData, $resourceType->getEntityClass(), $format, $context);
if (!$this->partService->isInternalPartNumberUnique($part->getInternalPartNumber(), $part)) {
throw new InternalPartNumberNotUniqueException();
}
return $part;
}
/**
* In an API context, converts any data to a XML response.
*
* @param GetResponseForControllerResultEvent $event
*
* @return Response|mixed
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$controllerResult = $event->getControllerResult();
if ($controllerResult instanceof Response) {
return $controllerResult;
}
$request = $event->getRequest();
$format = $request->attributes->get('_api_format');
if (self::FORMAT !== $format) {
return $controllerResult;
}
switch ($request->getMethod()) {
case Request::METHOD_POST:
$status = 201;
break;
case Request::METHOD_DELETE:
$status = 204;
break;
default:
$status = 200;
break;
}
$resourceType = $request->attributes->get('_resource_type');
$response = new Response($this->serializer->serialize($controllerResult, self::FORMAT, $resourceType->getNormalizationContext()), $status, ['Content-Type' => 'application/xml']);
$event->setResponse($response);
}
/**
* Create a new item.
*
* @param Request $request
* @param string|int $id
*
* @throws NotFoundHttpException
* @throws RuntimeException
* @throws UserProtectedException
* @throws UserLimitReachedException
*
* @return mixed
*/
public function __invoke(Request $request, $id)
{
/**
* @var ResourceInterface
*/
list($resourceType, $format) = $this->extractAttributes($request);
/**
* @var User
*/
$data = $this->getItem($this->dataProvider, $resourceType, $id);
$context = $resourceType->getDenormalizationContext();
$context['object_to_populate'] = $data;
if ($data->isProtected()) {
throw new UserProtectedException();
}
$data = $this->serializer->deserialize($request->getContent(), $resourceType->getEntityClass(), $format, $context);
if ($data->isActive()) {
if ($this->userService->checkUserLimit()) {
throw new UserLimitReachedException();
}
}
$this->userService->syncData($data);
$data->setNewPassword('');
$data->setPassword('');
$data->setLegacy(false);
return $data;
}
/**
* {@inheritdoc}
*/
public function normalize($entity, $format = null, array $context = [])
{
$data = $entity->getData();
$fieldName = $this->getFieldValue($entity);
$result = null;
if (is_array($data)) {
$data = new ArrayCollection($data);
}
if (is_null($data)) {
$result = [$fieldName => ''];
} elseif (is_int($data)) {
$result = [$fieldName => (string) $data];
} elseif (is_float($data)) {
$result = [$fieldName => sprintf(sprintf('%%.%sF', $this->precision), $data)];
} elseif (is_string($data)) {
$result = [$fieldName => $data];
} elseif (is_bool($data)) {
$result = [$fieldName => (string) (int) $data];
} elseif (is_object($data)) {
$context['field_name'] = $fieldName;
$result = $this->serializer->normalize($data, $format, $context);
}
if (null === $result) {
throw new \RuntimeException(sprintf('Cannot normalize product value "%s" which data is a(n) "%s"', $fieldName, is_object($data) ? get_class($data) : gettype($data)));
}
return $result;
}
/**
* @param $url
* @param array $params
*
* @return array
*/
public function get($url, $params = array())
{
$request = $this->provider->request($url, $params);
$response = $this->client->send($request);
$data = $response->getBody()->getContents();
$format = $this->getFormat($params, $response);
return $this->serializer->deserialize($data, null, $format);
}
/**
* {@inheritdoc}
*/
public function normalize($object, $format = null, array $context = array())
{
$normalizedItems = [];
foreach ($object as $item) {
$normalizedItems[$item->getLocale()] = $this->serializer->normalize($item, $format, $context);
}
return $normalizedItems;
}
function let(SerializerInterface $serializer, AbstractAttribute $simpleAttribute)
{
$serializer->implement('Symfony\\Component\\Serializer\\Normalizer\\NormalizerInterface');
$this->setSerializer($serializer);
$simpleAttribute->isLocalizable()->willReturn(false);
$simpleAttribute->isScopable()->willReturn(false);
$simpleAttribute->getCode()->willReturn('simple');
}
/**
* {@inheritdoc}
*/
public function current()
{
$result = parent::current();
if ($result !== null && $this->serializer) {
$result = $this->serializer->deserialize($result, $this->itemType, null, $this->deserializeContext);
}
return $result;
}
/**
* @expectedException \Symfony\Component\Serializer\Exception\CircularReferenceException
*/
public function testCircularNormalize()
{
$this->normalizer->setCircularReferenceLimit(1);
$this->serializer->expects($this->once())->method('normalize')->will($this->returnCallback(function ($data, $format, $context) {
$this->normalizer->normalize($data['qux'], $format, $context);
return 'string_object';
}));
$this->assertEquals('string_object', $this->normalizer->normalize(new JsonSerializableDummy()));
}
/**
* {@inheritdoc}
*/
public function normalize($entity, $format = null, array $context = [])
{
$data = $entity->getData();
$fieldName = $this->getFieldName($entity);
if ($this->filterLocaleSpecific($entity)) {
return [];
}
$result = null;
if (is_array($data)) {
$data = new ArrayCollection($data);
}
$type = $entity->getAttribute()->getAttributeType();
$backendType = $entity->getAttribute()->getBackendType();
if (AttributeTypes::BOOLEAN === $type) {
$result = [$fieldName => (string) (int) $data];
} elseif (is_null($data)) {
$result = [$fieldName => ''];
if ('metric' === $backendType) {
$result[$fieldName . '-unit'] = '';
}
} elseif (is_int($data)) {
$result = [$fieldName => (string) $data];
} elseif (is_float($data) || 'decimal' === $entity->getAttribute()->getBackendType()) {
$pattern = $entity->getAttribute()->isDecimalsAllowed() ? sprintf('%%.%sF', $this->precision) : '%d';
$result = [$fieldName => sprintf($pattern, $data)];
} elseif (is_string($data)) {
$result = [$fieldName => $data];
} elseif (is_object($data)) {
// TODO: Find a way to have proper currency-suffixed keys for normalized price data
// even when an empty collection is passed
if ('prices' === $backendType && $data instanceof Collection && $data->isEmpty()) {
$result = [];
} elseif ('options' === $backendType && $data instanceof Collection && $data->isEmpty() === false) {
$data = $this->sortOptions($data);
$context['field_name'] = $fieldName;
$result = $this->serializer->normalize($data, $format, $context);
} else {
$context['field_name'] = $fieldName;
if ('metric' === $backendType) {
$context['decimals_allowed'] = $entity->getAttribute()->isDecimalsAllowed();
} elseif ('media' === $backendType) {
$context['value'] = $entity;
}
$result = $this->serializer->normalize($data, $format, $context);
}
}
if (null === $result) {
throw new \RuntimeException(sprintf('Cannot normalize product value "%s" which data is a(n) "%s"', $fieldName, is_object($data) ? get_class($data) : gettype($data)));
}
$localizer = $this->localizerRegistry->getLocalizer($type);
if (null !== $localizer) {
foreach ($result as $field => $data) {
$result[$field] = $localizer->localize($data, $context);
}
}
return $result;
}
/**
* Create a new item.
*
* @param Request $request
* @param string|int $id
*
* @return mixed
*
* @throws NotFoundHttpException
* @throws RuntimeException
*/
public function __invoke(Request $request, $id)
{
list($resourceType, $format) = $this->extractAttributes($request);
$data = $this->getItem($this->dataProvider, $resourceType, $id);
$context = $resourceType->getDenormalizationContext();
$context['object_to_populate'] = $data;
$data = $this->serializer->deserialize($request->getContent(), $resourceType->getEntityClass(), $format, $context);
return $data;
}
/**
* {@inheritdoc}
*/
public function processRequest(Request $request, RouteMatchInterface $route_match, SerializerInterface $serializer)
{
if ($serializer instanceof DecoderInterface) {
$content = $serializer->decode($request->getContent(), $request->getContentType());
} else {
throw new HttpException(500, $this->t("The appropriate DecoderInterface was not found."));
}
if (!isset($content)) {
throw new HttpException(500, $this->t("The content of the request was empty."));
}
$flood_config = $this->configFactory->get('user.flood');
$username = $content['username'];
$password = $content['password'];
// Flood protection: this is very similar to the user login form code.
// @see \Drupal\user\Form\UserLoginForm::validateAuthentication()
// Do not allow any login from the current user's IP if the limit has been
// reached. Default is 50 failed attempts allowed in one hour. This is
// independent of the per-user limit to catch attempts from one IP to log
// in to many different user accounts. We have a reasonably high limit
// since there may be only one apparent IP for all users at an institution.
if ($this->flood->isAllowed('services.failed_login_ip', $flood_config->get('ip_limit'), $flood_config->get('ip_window'))) {
$accounts = $this->entityManager->getStorage('user')->loadByProperties(array('name' => $username, 'status' => 1));
$account = reset($accounts);
if ($account) {
if ($flood_config->get('uid_only')) {
// Register flood events based on the uid only, so they apply for any
// IP address. This is the most secure option.
$identifier = $account->id();
} else {
// The default identifier is a combination of uid and IP address. This
// is less secure but more resistant to denial-of-service attacks that
// could lock out all users with public user names.
$identifier = $account->id() . '-' . $request->getClientIP();
}
// Don't allow login if the limit for this user has been reached.
// Default is to allow 5 failed attempts every 6 hours.
if ($this->flood->isAllowed('services.failed_login_user', $flood_config->get('user_limit'), $flood_config->get('user_window'), $identifier)) {
$uid = $this->userAuth->authenticate($username, $password);
if ($uid) {
$this->flood->clear('services.failed_login_user', $identifier);
$this->session->start();
user_login_finalize($account);
drupal_set_message(t('User succesffully logged in'), 'status', FALSE);
return ['id' => $this->session->getId(), 'name' => $this->session->getName()];
//return $this->entityManager->getStorage('user')->load($uid);
} else {
// Register a per-user failed login event.
$this->flood->register('services.failed_login_user', $flood_config->get('user_window'), $identifier);
}
}
}
}
// Always register an IP-based failed login event.
$this->flood->register('services.failed_login_ip', $flood_config->get('ip_window'));
return [];
}
/**
* {@inheritdoc}
*/
protected function setUp()
{
$this->normalizer = new EntityReferenceFieldItemNormalizer();
$this->serializer = $this->prophesize(Serializer::class);
// Set up the serializer to return an entity property.
$this->serializer->normalize(Argument::cetera())->willReturn(['value' => 'test']);
$this->normalizer->setSerializer($this->serializer->reveal());
$this->fieldItem = $this->prophesize(EntityReferenceItem::class);
$this->fieldItem->getIterator()->willReturn(new \ArrayIterator(['target_id' => []]));
}
public function normalize(Kwf_Model_Row_Interface $row, $column, array $settings, $format = null, array $context = array())
{
if (!isset($settings['rule'])) {
throw new \Exception("rule setting is required");
}
$rows = $row->getChildRows($settings['rule']);
if (isset($settings['groups'])) {
$context['groups'] = $settings['groups'];
}
return $this->serializer->normalize($rows, $format, $context);
}
/**
* {@inheritdoc}
*/
public function process($item)
{
if ($this->converter) {
$item = $this->converter->convertToImportFormat($item);
}
$object = $this->serializer->deserialize($item, $this->context->getOption('entityName'), null);
if ($this->strategy) {
$object = $this->strategy->process($object);
}
return $object ?: null;
}
/**
* Injects the specific root node ID if "@local-tree-root" was specified
*
* @param Request $request
*
* @return mixed
*
* @throws RuntimeException
* @throws PartLimitExceededException
*/
public function __invoke(Request $request)
{
/**
* @var $resourceType ResourceInterface
*/
if ($this->partService->checkPartLimit()) {
throw new PartLimitExceededException();
}
list($resourceType, $format) = $this->extractAttributes($request);
return $this->serializer->deserialize($request->getContent(), $resourceType->getEntityClass(), $format, $resourceType->getDenormalizationContext());
}
public function testMakeDto()
{
$commentDto = m::mock(CommentDto::class);
$parameterBag = m::mock(ParameterBagInterface::class);
$parameterBag->shouldReceive('get')->once()->andReturn(567);
$request = m::mock(Request::class);
$request->shouldReceive('getContent')->once();
$request->attributes = $parameterBag;
$this->serializer->shouldReceive('deserialize')->once()->andReturn($commentDto);
$this->commentDtoFactory->makeDto($request);
}
/**
* Processes entity to export format
*
* @param mixed $object
* @return array
* @throws RuntimeException
*/
public function process($object)
{
if (!$this->serializer) {
throw new RuntimeException('Serializer must be injected.');
}
$data = $this->serializer->serialize($object, null);
if ($this->dataConverter) {
$data = $this->dataConverter->convertToExportFormat($data);
}
return $data;
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
if (empty($data)) {
return null;
}
$options = new ArrayCollection();
foreach ($data as $optionCode) {
$option = $this->serializer->denormalize($optionCode, 'pim_catalog_simpleselect', $format, $context);
$options->add($option);
}
return $options;
}
/**
* {@inheritdoc}
*/
public function process($item)
{
if ($this->dataConverter) {
$item = $this->dataConverter->convertToImportFormat($item, false);
}
$this->context->setValue('itemData', $item);
$object = $this->serializer->deserialize($item, $this->context->getOption('entityName'), null, $this->context->getConfiguration());
if ($this->strategy) {
$object = $this->strategy->process($object);
}
return $object ?: null;
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
if (empty($data)) {
return null;
}
$options = new ArrayCollection();
foreach ($data as $optionCode) {
$option = $this->serializer->denormalize($optionCode, AttributeTypes::OPTION_SIMPLE_SELECT, $format, $context);
$options->add($option);
}
return $options;
}
/**
* {@inheritdoc}
*
* @return \Drupal\Core\Entity\EntityInterface|array
*/
public function processRequest(Request $request, RouteMatchInterface $route_match, SerializerInterface $serializer)
{
// Unserialize the content of the request if there is any.
$content = $request->getContent();
if (!empty($content)) {
$entity_type_id = $this->getDerivativeId();
/** @var $entity_type \Drupal\Core\Entity\EntityTypeInterface */
$entity_type = $this->manager->getDefinition($entity_type_id);
return $serializer->deserialize($content, $entity_type->getClass(), $request->getContentType(), ['entity_type' => $entity_type_id]);
}
return [];
}
/**
* {@inheritdoc}
*/
public function normalize($data, $format = null, array $context = [])
{
$result = [];
foreach ($data as $value) {
if ($value instanceof ProductValueInterface) {
$result[$value->getAttribute()->getCode()][] = $this->serializer->normalize($value, 'json', $context);
} else {
$result[] = $this->serializer->normalize($value, 'json', $context);
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function normalize($entity, $format = null, array $context = [])
{
if ($entity->getData() instanceof Collection) {
$value = [];
foreach ($entity->getData() as $item) {
$value[] = $this->serializer->normalize($item, $format, $context);
}
} else {
$value = $this->serializer->normalize($entity->getData(), $format, $context);
}
return ['locale' => $entity->getLocale(), 'scope' => $entity->getScope(), 'value' => $value];
}
/**
* Return a list of class guessed
*
* @param $swaggerSpec
* @param $name
* @param $namespace
* @param $directory
*
* @return Context
*/
public function createContext($swaggerSpec, $name, $namespace, $directory)
{
$schema = $this->serializer->deserialize(file_get_contents($swaggerSpec), Swagger::class, 'json');
$classes = $this->chainGuesser->guessClass($schema, $name);
foreach ($classes as $class) {
$properties = $this->chainGuesser->guessProperties($class->getObject(), $name, $classes);
foreach ($properties as $property) {
$property->setType($this->chainGuesser->guessType($property->getObject(), $property->getName(), $classes));
}
$class->setProperties($properties);
}
return new Context($schema, $namespace, $directory, $classes);
}
/**
* {@inheritdoc}
*/
public function process($product)
{
$data['media'] = [];
$productMedias = $this->getProductMedias($product);
if (count($productMedias) > 0) {
try {
$data['media'] = $this->serializer->normalize($productMedias, 'flat', ['field_name' => 'media', 'prepare_copy' => true]);
} catch (FileNotFoundException $e) {
throw new InvalidItemException($e->getMessage(), ['item' => $product->getIdentifier()->getData(), 'uploadDirectory' => $this->uploadDirectory]);
}
}
$data['product'] = $this->serializer->normalize($product, 'flat', $this->getNormalizerContext());
return $data;
}
public function onManifestPush(ManifestEvent $event)
{
$manifest = $event->getManifest();
$message = new Message($this->serializer->serialize($manifest, 'json', ['groups' => ['manifest_push']]));
$this->publisher->publish('manifest_push', $message);
$manifest->setUpdatedAt(new \DateTime());
$this->om->flush();
}