/**
* @param $id
* @param $className
* @param callable $findOneCallable
* @param callable $deleteCallable
*
* @return \Symfony\Component\HttpFoundation\Response
*/
public function get($id, $className, callable $findOneCallable, callable $deleteCallable)
{
try {
$data = $findOneCallable();
if (empty($data)) {
$mapping = $this->serializer->getTransformer()->getMappingByClassName($className);
return $this->resourceNotFound(new ErrorBag([new NotFoundError($mapping->getClassAlias(), $id)]));
}
$deleteCallable();
return $this->resourceDeleted();
} catch (Exception $e) {
return $this->errorResponse(new ErrorBag([new Error('Bad Request', 'Request could not be served.')]));
}
}
/**
* @param string|int $id
* @param string $className
* @param callable $callable
*
* @return \Symfony\Component\HttpFoundation\Response
*/
public function get($id, $className, callable $callable)
{
try {
QueryObject::assert($this->serializer, $this->fields, $this->included, new Sorting(), $this->errorBag, $className);
$data = $callable();
if (empty($data)) {
$mapping = $this->serializer->getTransformer()->getMappingByClassName($className);
return $this->resourceNotFound(new ErrorBag([new NotFoundError($mapping->getClassAlias(), $id)]));
}
$response = $this->response($this->serializer->serialize($data, $this->fields, $this->included));
} catch (Exception $e) {
$response = $this->getErrorResponse($e);
}
return $response;
}
/**
* @param $id
* @param array $data
* @param $className
* @param callable $findOneCallable
* @param callable $update
*
* @return \Symfony\Component\HttpFoundation\Response
*/
public function get($id, array $data, $className, callable $findOneCallable, callable $update)
{
try {
DataObject::assertPut($data, $this->serializer, $className, $this->errorBag);
$model = $findOneCallable();
if (empty($model)) {
$mapping = $this->serializer->getTransformer()->getMappingByClassName($className);
return $this->resourceNotFound(new ErrorBag([new NotFoundError($mapping->getClassAlias(), $id)]));
}
$values = DataObject::getAttributes($data, $this->serializer);
$update($model, $values, $this->errorBag);
$response = $this->resourceUpdated($this->serializer->serialize($model));
} catch (Exception $e) {
$response = $this->getErrorResponse($e);
}
return $response;
}
/**
* @param JsonApiSerializer $serializer
* @param Included $included
* @param string $paramName
*/
protected function validateIncludeQueryParamsTypes($serializer, Included $included, $paramName)
{
if (false === $included->isEmpty()) {
$validateFields = array_keys($included->get());
foreach ($validateFields as $key => $field) {
$mapping = $serializer->getTransformer()->getMappingByAlias($field);
if (null !== $mapping) {
$properties = $this->getPropertiesFromMapping($mapping);
$invalidProperties = array_diff($included->get()[$field], $properties);
$this->addInvalidParameterMemberErrorsToErrorBag($invalidProperties, $paramName, $field);
unset($validateFields[$key]);
}
}
$this->addInvalidParameterErrorsToErrorBag($paramName, $validateFields);
}
}
public function testGetTransformerReturnsJsonApiTransformer()
{
$serializer = new JsonApiSerializer(new JsonApiTransformer(new Mapper(HelperMapping::complex())));
$this->assertInstanceOf(JsonApiTransformer::class, $serializer->getTransformer());
}
/**
* @param array $relationshipData
* @param JsonApiSerializer $serializer
* @param ErrorBag $errorBag
*/
protected static function relationshipDataAssert($relationshipData, JsonApiSerializer $serializer, ErrorBag $errorBag)
{
//Has type member.
if (empty($relationshipData[JsonApiTransformer::TYPE_KEY]) || !is_string($relationshipData[JsonApiTransformer::TYPE_KEY])) {
$errorBag[] = new MissingTypeError();
return;
}
//Provided type value is supported.
if (null === $serializer->getTransformer()->getMappingByAlias($relationshipData[JsonApiTransformer::TYPE_KEY])) {
$errorBag[] = new InvalidTypeError($relationshipData[JsonApiTransformer::TYPE_KEY]);
return;
}
//Validate if attributes passed in make sense.
if (!empty($relationshipData[JsonApiTransformer::ATTRIBUTES_KEY])) {
$mapping = $serializer->getTransformer()->getMappingByAlias($relationshipData[JsonApiTransformer::TYPE_KEY]);
$properties = str_replace(array_keys($mapping->getAliasedProperties()), array_values($mapping->getAliasedProperties()), $mapping->getProperties());
foreach (array_keys($relationshipData[JsonApiTransformer::ATTRIBUTES_KEY]) as $property) {
if (false === in_array($property, $properties, true)) {
$errorBag[] = new InvalidAttributeError($property, $relationshipData[JsonApiTransformer::TYPE_KEY]);
}
}
}
}
/**
* @param JsonApiSerializer $serializer
* @param string $className
* @param Sorting $sorting
* @param ErrorBag $errorBag
*/
protected static function validateSortParams(JsonApiSerializer $serializer, $className, Sorting $sorting, ErrorBag $errorBag)
{
if (false === $sorting->isEmpty()) {
if ($mapping = $serializer->getTransformer()->getMappingByClassName($className)) {
$aliased = (array) $mapping->getAliasedProperties();
$sortsFields = str_replace(array_values($aliased), array_keys($aliased), $sorting->fields());
$invalidProperties = array_diff($sortsFields, $mapping->getProperties());
foreach ($invalidProperties as $extraField) {
$errorBag[] = new InvalidSortError($extraField);
}
}
}
}
/**
* @param array $data
* @param JsonApiSerializer $serializer
* @param ErrorBag $errorBag
*
* @throws DataException
*/
protected static function assertAttributesExists(array $data, JsonApiSerializer $serializer, ErrorBag $errorBag)
{
$inputAttributes = array_keys($data[JsonApiTransformer::ATTRIBUTES_KEY]);
$mapping = $serializer->getTransformer()->getMappingByAlias($data[JsonApiTransformer::TYPE_KEY]);
$properties = str_replace(array_keys($mapping->getAliasedProperties()), array_values($mapping->getAliasedProperties()), $mapping->getProperties());
$properties = array_diff($properties, $mapping->getIdProperties());
$properties = array_merge($properties, $mapping->getHiddenProperties());
$hasErrors = false;
foreach ($inputAttributes as $property) {
if (false === in_array($property, $properties)) {
$hasErrors = true;
$errorBag[] = new InvalidAttributeError($property, $data[JsonApiTransformer::TYPE_KEY]);
}
}
if ($hasErrors) {
throw new DataException();
}
}