yvan/gallery-api
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* doctrine db cache backend added

Browse Source
This commit is contained in:
Danyi Dávid 2017-08-12 22:56:25 +02:00
parent 36fa6c3297
commit 771db00c4f
22 changed files with 2368 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
cli-config.php Normal file
View File

@ -0,0 +1,9 @@
<?php
$container = require 'config/container.php';
return new \Symfony\Component\Console\Helper\HelperSet([
'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper(
$container->get('doctrine.entity_manager.orm_default')
),
]);

3
composer.json
View File

@ -7,8 +7,11 @@
"config": {
"sort-packages": true
},
"minimum-stability": "dev",
"prefer-stable": true,
"require": {
"php": "^7.1",
"dasprid/container-interop-doctrine": "^1.0",
"imagine/imagine": "^0.7.1",
"roave/security-advisories": "dev-master",
"symfony/yaml": "*",

987
composer.lock generated
View File

File diff suppressed because it is too large Load Diff

68
config/autoload/doctrine.global.php Normal file
View File

@ -0,0 +1,68 @@
<?php
return [
'doctrine' => [
'driver' => [
'orm_default' => [
'class' => \Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain::class,
'drivers' => [
'App\Entity' => 'my_entity',
],
],
'my_entity' => [
'class' => \Doctrine\ORM\Mapping\Driver\AnnotationDriver::class,
'cache' => 'array',
'paths' => __DIR__ . '/../../src/App/Entity',
],
],
'configuration' => [
'orm_default' => [
// 'datetime_functions' => [
// 'date' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'time' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'timestamp' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'convert_tz' => Oro\ORM\Query\AST\Functions\DateTime\ConvertTz::class,
// ],
// 'numeric_functions' => [
// 'timestampdiff' => Oro\ORM\Query\AST\Functions\Numeric\TimestampDiff::class,
// 'dayofyear' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'dayofmonth' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'dayofweek' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'week' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'day' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'hour' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'minute' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'month' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'quarter' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'second' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'year' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'sign' => Oro\ORM\Query\AST\Functions\Numeric\Sign::class,
// 'pow' => Oro\ORM\Query\AST\Functions\Numeric\Pow::class,
// ],
// 'string_functions' => [
// 'md5' => Oro\ORM\Query\AST\Functions\SimpleFunction::class,
// 'group_concat' => Oro\ORM\Query\AST\Functions\String\GroupConcat::class,
// 'cast' => Oro\ORM\Query\AST\Functions\Cast::class,
// 'concat_ws' => Oro\ORM\Query\AST\Functions\String\ConcatWs::class
// ]
// 'filters' => [
// 'soft-deleteable' => Gedmo\SoftDeleteable\Filter\SoftDeleteableFilter::class,
// ],
],
],
'event_manager' => [
'orm_default' => [
'subscribers' => [
// Gedmo\Timestampable\TimestampableListener::class,
// 'Gedmo\Tree\TreeListener',
// 'Gedmo\SoftDeleteable\SoftDeleteableListener',
// 'Gedmo\Translatable\TranslatableListener',
// 'Gedmo\Blameable\BlameableListener',
// 'Gedmo\Loggable\LoggableListener',
// 'Gedmo\Sortable\SortableListener',
// 'Gedmo\Sluggable\SluggableListener',
],
],
],
],
];

14
config/autoload/doctrine.local.dist.php Normal file
View File

@ -0,0 +1,14 @@
<?php
return [
'doctrine' => [
'connection' => [
'orm_default' => [
'params' => [
'url' => 'sqlite:///data/gallery.db',
'charset' => 'UTF8',
],
],
],
],
];

1
config/routes.php
View File

@ -28,5 +28,4 @@
$app->get('/', App\Action\HomePageAction::class, 'home');
$app->get('/api/galleries', App\Action\ListGalleriesAction::class, 'api.galleries');
$app->get('/api/gallery/{slug}', App\Action\GetGalleryImagesAction::class, 'api.gallery');
$app->get('/image/{slug}/{image}[/{thumb}]', App\Action\GetImageAction::class, 'download.image');

25
src/App/Action/GetGalleryImagesAction.php
View File

@ -1,25 +0,0 @@
<?php
namespace App\Action;
use App\Response\JsonCorsResponse;
use App\Service\GalleryService;
use Interop\Http\ServerMiddleware\DelegateInterface;
use Interop\Http\ServerMiddleware\MiddlewareInterface as ServerMiddlewareInterface;
use Psr\Http\Message\ServerRequestInterface;
class GetGalleryImagesAction implements ServerMiddlewareInterface
{
private $galleryService;
public function __construct(GalleryService $galleryService)
{
$this->galleryService = $galleryService;
}
public function process(ServerRequestInterface $request, DelegateInterface $delegate)
{
$slug = $request->getAttribute('slug', false);
return new JsonCorsResponse($this->galleryService->getGallery($slug));
}
}

15
src/App/Action/GetGalleryImagesFactory.php
View File

@ -1,15 +0,0 @@
<?php
namespace App\Action;
use App\Service\GalleryService;
use Interop\Container\ContainerInterface;
class GetGalleryImagesFactory
{
public function __invoke(ContainerInterface $container)
{
$galleryService = $container->get(GalleryService::class);
return new GetGalleryImagesAction($galleryService);
}
}

1
src/App/Action/ListGalleriesAction.php
View File

@ -19,7 +19,6 @@ class ListGalleriesAction implements ServerMiddlewareInterface
public function process(ServerRequestInterface $request, DelegateInterface $delegate)
{
// return new JsonCorsResponse($this->galleryService->listGalleries(true));
return new JsonCorsResponse($this->galleryService->loadGalleryData(true));
}
}

9
src/App/ConfigProvider.php
View File

@ -2,6 +2,8 @@
namespace App;
use ContainerInteropDoctrine\EntityManagerFactory;
/**
* The configuration provider for the App module
*
@ -34,13 +36,16 @@ class ConfigProvider
{
return [
'invokables' => [
Service\GalleryService::class => Service\GalleryService::class,
Action\HomePageAction::class => Action\HomePageAction::class,
],
'factories' => [
'doctrine.entity_manager.orm_default' => EntityManagerFactory::class,
'doctrine.hydrator' => Hydrator\DoctrineObjectFactory::class,
Action\ListGalleriesAction::class => Action\ListGalleriesFactory::class,
Action\GetGalleryImagesAction::class => Action\GetGalleryImagesFactory::class,
Action\GetImageAction::class => Action\GetImageFactory::class,
Service\GalleryService::class => Service\GalleryServiceFactory::class,
],
];
}

20
src/App/Entity/Album.php Normal file
View File

@ -0,0 +1,20 @@
<?php
namespace App\Entity;
class Album
{
const TYPE_STANDARD = 0;
const TYPE_PANORAMA = 1;
protected $slug;
protected $dir;
protected $name;
protected $coverImage;
protected $type;
protected $new;
protected $public;
protected $images;
}

177
src/App/Entity/Image.php Normal file
View File

@ -0,0 +1,177 @@
<?php
namespace App\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
* @ORM\Entity
* @ORM\Table(
* name="images",
* indexes={
* @ORM\Index(name="dir_idx", columns={"dir"}),
* @ORM\Index(name="path_idx", columns={"path"})
* }
* )
* @ORM\HasLifecycleCallbacks
*/
class Image implements \JsonSerializable
{
/**
* @ORM\Id
* @ORM\Column(name="id", type="integer")
* @ORM\GeneratedValue(strategy="IDENTITY")
* @var int
*/
private $id;
/**
* @ORM\Column(name="dir", type="string", length=255, nullable=false)
* @var string
*/
private $dir = "";
/**
* @ORM\Column(name="label", type="string", length=250, nullable=true)
* @var string
*/
private $label = "";
/**
* @ORM\Column(name="path", type="string", length=250, nullable=false)
* @var string
*/
private $path = "";
/**
* @ORM\Column(name="width", type="integer")
* @var string
*/
private $width = 0;
/**
* @ORM\Column(name="type", type="integer")
* @var string
*/
private $height = 0;
/**
* @return int
*/
public function getId(): ?int
{
return $this->id;
}
/**
* @param mixed $id
* @return Image
*/
public function setId(?int $id): Image
{
$this->id = $id;
return $this;
}
/**
* @return string
*/
public function getDir(): ?string
{
return $this->dir;
}
/**
* @param string $dir
* @return Image
*/
public function setDir(?string $dir): Image
{
$this->dir = $dir;
return $this;
}
/**
* @return string
*/
public function getLabel(): ?string
{
return $this->label;
}
/**
* @param string $label
* @return Image
*/
public function setLabel(?string $label): Image
{
$this->label = $label;
return $this;
}
/**
* @return string
*/
public function getPath(): ?string
{
return $this->path;
}
/**
* @param string $path
* @return Image
*/
public function setPath(?string $path): Image
{
$this->path = $path;
return $this;
}
/**
* @return int
*/
public function getWidth(): ?int
{
return $this->width;
}
/**
* @param int $width
* @return Image
*/
public function setWidth(?int $width): Image
{
$this->width = $width;
return $this;
}
/**
* @return int
*/
public function getHeight(): ?int
{
return $this->height;
}
/**
* @param int $height
* @return Image
*/
public function setHeight(?int $height): Image
{
$this->height = $height;
return $this;
}
public function jsonSerialize()
{
return [
'dir' => $this->getDir(),
'label' => $this->getLabel(),
'path' => $this->getPath(),
'width' => $this->getWidth(),
'height' => $this->getHeight(),
];
}
}

594
src/App/Hydrator/DoctrineObject.php Normal file
View File

@ -0,0 +1,594 @@
<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace App\Hydrator;
use DateTime;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Util\Inflector;
use InvalidArgumentException;
use RuntimeException;
use Traversable;
use Zend\Stdlib\ArrayUtils;
use Zend\Hydrator\AbstractHydrator;
use Zend\Hydrator\Filter\FilterProviderInterface;
/**
* This hydrator has been completely refactored for DoctrineModule 0.7.0. It provides an easy and powerful way
* of extracting/hydrator objects in Doctrine, by handling most associations types.
*
* Starting from DoctrineModule 0.8.0, the hydrator can be used multiple times with different objects
*
* @license MIT
* @link http://www.doctrine-project.org/
* @since 0.7.0
* @author Michael Gallego <mic.gallego@gmail.com>
*/
class DoctrineObject extends AbstractHydrator
{
/**
* @var ObjectManager
*/
protected $objectManager;
/**
* @var ClassMetadata
*/
protected $metadata;
/**
* @var bool
*/
protected $byValue = true;
/**
* Constructor
*
* @param ObjectManager $objectManager The ObjectManager to use
* @param bool $byValue If set to true, hydrator will always use entity's public API
*/
public function __construct(ObjectManager $objectManager, $byValue = true)
{
parent::__construct();
$this->objectManager = $objectManager;
$this->byValue = (bool) $byValue;
}
/**
* Extract values from an object
*
* @param object $object
* @return array
*/
public function extract($object)
{
$this->prepare($object);
if ($this->byValue) {
return $this->extractByValue($object);
}
return $this->extractByReference($object);
}
/**
* Hydrate $object with the provided $data.
*
* @param array $data
* @param object $object
* @return object
*/
public function hydrate(array $data, $object)
{
$this->prepare($object);
if ($this->byValue) {
return $this->hydrateByValue($data, $object);
}
return $this->hydrateByReference($data, $object);
}
/**
* Prepare the hydrator by adding strategies to every collection valued associations
*
* @param object $object
* @return void
*/
protected function prepare($object)
{
$this->metadata = $this->objectManager->getClassMetadata(get_class($object));
$this->prepareStrategies();
}
/**
* Prepare strategies before the hydrator is used
*
* @throws \InvalidArgumentException
* @return void
*/
protected function prepareStrategies()
{
$associations = $this->metadata->getAssociationNames();
foreach ($associations as $association) {
if ($this->metadata->isCollectionValuedAssociation($association)) {
// Add a strategy if the association has none set by user
if (!$this->hasStrategy($association)) {
if ($this->byValue) {
$this->addStrategy($association, new Strategy\AllowRemoveByValue());
} else {
$this->addStrategy($association, new Strategy\AllowRemoveByReference());
}
}
$strategy = $this->getStrategy($association);
if (!$strategy instanceof Strategy\AbstractCollectionStrategy) {
throw new InvalidArgumentException(
sprintf(
'Strategies used for collections valued associations must inherit from '
. 'Strategy\AbstractCollectionStrategy, %s given',
get_class($strategy)
)
);
}
$strategy->setCollectionName($association)
->setClassMetadata($this->metadata);
}
}
}
/**
* Extract values from an object using a by-value logic (this means that it uses the entity
* API, in this case, getters)
*
* @param object $object
* @throws RuntimeException
* @return array
*/
protected function extractByValue($object)
{
$fieldNames = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames());
$methods = get_class_methods($object);
$filter = $object instanceof FilterProviderInterface
? $object->getFilter()
: $this->filterComposite;
$data = [];
foreach ($fieldNames as $fieldName) {
if ($filter && !$filter->filter($fieldName)) {
continue;
}
$getter = 'get' . Inflector::classify($fieldName);
$isser = 'is' . Inflector::classify($fieldName);
$dataFieldName = $this->computeExtractFieldName($fieldName);
if (in_array($getter, $methods)) {
$data[$dataFieldName] = $this->extractValue($fieldName, $object->$getter(), $object);
} elseif (in_array($isser, $methods)) {
$data[$dataFieldName] = $this->extractValue($fieldName, $object->$isser(), $object);
} elseif (substr($fieldName, 0, 2) === 'is'
&& ctype_upper(substr($fieldName, 2, 1))
&& in_array($fieldName, $methods)) {
$data[$dataFieldName] = $this->extractValue($fieldName, $object->$fieldName(), $object);
}
// Unknown fields are ignored
}
return $data;
}
/**
* Extract values from an object using a by-reference logic (this means that values are
* directly fetched without using the public API of the entity, in this case, getters)
*
* @param object $object
* @return array
*/
protected function extractByReference($object)
{
$fieldNames = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames());
$refl = $this->metadata->getReflectionClass();
$filter = $object instanceof FilterProviderInterface
? $object->getFilter()
: $this->filterComposite;
$data = [];
foreach ($fieldNames as $fieldName) {
if ($filter && !$filter->filter($fieldName)) {
continue;
}
$reflProperty = $refl->getProperty($fieldName);
$reflProperty->setAccessible(true);
$dataFieldName = $this->computeExtractFieldName($fieldName);
$data[$dataFieldName] = $this->extractValue($fieldName, $reflProperty->getValue($object), $object);
}
return $data;
}
/**
* Hydrate the object using a by-value logic (this means that it uses the entity API, in this
* case, setters)
*
* @param array $data
* @param object $object
* @throws RuntimeException
* @return object
*/
protected function hydrateByValue(array $data, $object)
{
$tryObject = $this->tryConvertArrayToObject($data, $object);
$metadata = $this->metadata;
if (is_object($tryObject)) {
$object = $tryObject;
}
foreach ($data as $field => $value) {
$field = $this->computeHydrateFieldName($field);
$value = $this->handleTypeConversions($value, $metadata->getTypeOfField($field));
$setter = 'set' . Inflector::classify($field);
if ($metadata->hasAssociation($field)) {
$target = $metadata->getAssociationTargetClass($field);
if ($metadata->isSingleValuedAssociation($field)) {
if (! method_exists($object, $setter)) {
continue;
}
$value = $this->toOne($target, $this->hydrateValue($field, $value, $data));
if (null === $value
&& !current($metadata->getReflectionClass()->getMethod($setter)->getParameters())->allowsNull()
) {
continue;
}
$object->$setter($value);
} elseif ($metadata->isCollectionValuedAssociation($field)) {
$this->toMany($object, $field, $target, $value);
}
} else {
if (! method_exists($object, $setter)) {
continue;
}
$object->$setter($this->hydrateValue($field, $value, $data));
}
}
return $object;
}
/**
* Hydrate the object using a by-reference logic (this means that values are modified directly without
* using the public API, in this case setters, and hence override any logic that could be done in those
* setters)
*
* @param array $data
* @param object $object
* @return object
*/
protected function hydrateByReference(array $data, $object)
{
$tryObject = $this->tryConvertArrayToObject($data, $object);
$metadata = $this->metadata;
$refl = $metadata->getReflectionClass();
if (is_object($tryObject)) {
$object = $tryObject;
}
foreach ($data as $field => $value) {
$field = $this->computeHydrateFieldName($field);
// Ignore unknown fields
if (!$refl->hasProperty($field)) {
continue;
}
$value = $this->handleTypeConversions($value, $metadata->getTypeOfField($field));
$reflProperty = $refl->getProperty($field);
$reflProperty->setAccessible(true);
if ($metadata->hasAssociation($field)) {
$target = $metadata->getAssociationTargetClass($field);
if ($metadata->isSingleValuedAssociation($field)) {
$value = $this->toOne($target, $this->hydrateValue($field, $value, $data));
$reflProperty->setValue($object, $value);
} elseif ($metadata->isCollectionValuedAssociation($field)) {
$this->toMany($object, $field, $target, $value);
}
} else {
$reflProperty->setValue($object, $this->hydrateValue($field, $value, $data));
}
}
return $object;
}
/**
* This function tries, given an array of data, to convert it to an object if the given array contains
* an identifier for the object. This is useful in a context of updating existing entities, without ugly
* tricks like setting manually the existing id directly into the entity
*
* @param array $data The data that may contain identifiers keys
* @param object $object
* @return object
*/
protected function tryConvertArrayToObject($data, $object)
{
$metadata = $this->metadata;
$identifierNames = $metadata->getIdentifierFieldNames($object);
$identifierValues = [];
if (empty($identifierNames)) {
return $object;
}
foreach ($identifierNames as $identifierName) {
if (!isset($data[$identifierName])) {
return $object;
}
$identifierValues[$identifierName] = $data[$identifierName];
}
return $this->find($identifierValues, $metadata->getName());
}
/**
* Handle ToOne associations
*
* When $value is an array but is not the $target's identifiers, $value is
* most likely an array of fieldset data. The identifiers will be determined
* and a target instance will be initialized and then hydrated. The hydrated
* target will be returned.
*
* @param string $target
* @param mixed $value
* @return object
*/
protected function toOne($target, $value)
{
$metadata = $this->objectManager->getClassMetadata($target);
if (is_array($value) && array_keys($value) != $metadata->getIdentifier()) {
// $value is most likely an array of fieldset data
$identifiers = array_intersect_key(
$value,
array_flip($metadata->getIdentifier())
);
$object = $this->find($identifiers, $target) ?: new $target;
return $this->hydrate($value, $object);
}
return $this->find($value, $target);
}
/**
* Handle ToMany associations. In proper Doctrine design, Collections should not be swapped, so
* collections are always handled by reference. Internally, every collection is handled using specials
* strategies that inherit from AbstractCollectionStrategy class, and that add or remove elements but without
* changing the collection of the object
*
* @param object $object
* @param mixed $collectionName
* @param string $target
* @param mixed $values
*
* @throws \InvalidArgumentException
*
* @return void
*/
protected function toMany($object, $collectionName, $target, $values)
{
$metadata = $this->objectManager->getClassMetadata(ltrim($target, '\\'));
$identifier = $metadata->getIdentifier();
if (!is_array($values) && !$values instanceof Traversable) {
$values = (array)$values;
}
$collection = [];
// If the collection contains identifiers, fetch the objects from database
foreach ($values as $value) {
if ($value instanceof $target) {
// assumes modifications have already taken place in object
$collection[] = $value;
continue;
} elseif (empty($value)) {
// assumes no id and retrieves new $target
$collection[] = $this->find($value, $target);
continue;
}
$find = [];
if (is_array($identifier)) {
foreach ($identifier as $field) {
switch (gettype($value)) {
case 'object':
$getter = 'get' . ucfirst($field);
if (method_exists($value, $getter)) {
$find[$field] = $value->$getter();
} elseif (property_exists($value, $field)) {
$find[$field] = $value->$field;
}
break;
case 'array':
if (array_key_exists($field, $value) && $value[$field] != null) {
$find[$field] = $value[$field];
unset($value[$field]); // removed identifier from persistable data
}
break;
default:
$find[$field] = $value;
break;
}
}
}
if (!empty($find) && $found = $this->find($find, $target)) {
$collection[] = (is_array($value)) ? $this->hydrate($value, $found) : $found;
} else {
$collection[] = (is_array($value)) ? $this->hydrate($value, new $target) : new $target;
}
}
$collection = array_filter(
$collection,
function ($item) {
return null !== $item;
}
);
// Set the object so that the strategy can extract the Collection from it
/** @var \DoctrineModule\Stdlib\Hydrator\Strategy\AbstractCollectionStrategy $collectionStrategy */
$collectionStrategy = $this->getStrategy($collectionName);
$collectionStrategy->setObject($object);
// We could directly call hydrate method from the strategy, but if people want to override
// hydrateValue function, they can do it and do their own stuff
$this->hydrateValue($collectionName, $collection, $values);
}
/**
* Handle various type conversions that should be supported natively by Doctrine (like DateTime)
*
* @param mixed $value
* @param string $typeOfField
* @return DateTime
*/
protected function handleTypeConversions($value, $typeOfField)
{
switch ($typeOfField) {
case 'datetimetz':
case 'datetime':
case 'time':
case 'date':
if ('' === $value) {
return null;
}
if (is_int($value)) {
$dateTime = new DateTime();
$dateTime->setTimestamp($value);
$value = $dateTime;
} elseif (is_string($value)) {
$value = new DateTime($value);
}
break;
default:
}
return $value;
}
/**
* Find an object by a given target class and identifier
*
* @param mixed $identifiers
* @param string $targetClass
*
* @return object|null
*/
protected function find($identifiers, $targetClass)
{
if ($identifiers instanceof $targetClass) {
return $identifiers;
}
if ($this->isNullIdentifier($identifiers)) {
return null;
}
return $this->objectManager->find($targetClass, $identifiers);
}
/**
* Verifies if a provided identifier is to be considered null
*
* @param mixed $identifier
*
* @return bool
*/
private function isNullIdentifier($identifier)
{
if (null === $identifier) {
return true;
}
if ($identifier instanceof Traversable || is_array($identifier)) {
$nonNullIdentifiers = array_filter(
ArrayUtils::iteratorToArray($identifier),
function ($value) {
return null !== $value;
}
);
return empty($nonNullIdentifiers);
}
return false;
}
/**
* Applies the naming strategy if there is one set
*
* @param string $field
*
* @return string
*/
protected function computeHydrateFieldName($field)
{
if ($this->hasNamingStrategy()) {
$field = $this->getNamingStrategy()->hydrate($field);
}
return $field;
}
/**
* Applies the naming strategy if there is one set
*
* @param string $field
*
* @return string
*/
protected function computeExtractFieldName($field)
{
if ($this->hasNamingStrategy()) {
$field = $this->getNamingStrategy()->extract($field);
}
return $field;
}
}

15
src/App/Hydrator/DoctrineObjectFactory.php Normal file
View File

@ -0,0 +1,15 @@
<?php
namespace App\Hydrator;
use Interop\Container\ContainerInterface;
class DoctrineObjectFactory
{
public function __invoke(ContainerInterface $container)
{
$em = $container->get('doctrine.entity_manager.orm_default');
return new DoctrineObject($em);
}
}

66
src/App/Hydrator/Filter/PropertyName.php Normal file
View File

@ -0,0 +1,66 @@
<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace App\Hydrator\Filter;
use Zend\Hydrator\Filter\FilterInterface;
/**
* Provides a filter to restrict returned fields by whitelisting or
* blacklisting property names.
*
* @license MIT
* @link http://www.doctrine-project.org/
* @author Liam O'Boyle <liam@ontheroad.net.nz>
*/
class PropertyName implements FilterInterface
{
/**
* The propteries to exclude.
*
* @var array
*/
protected $properties = [];
/**
* Either an exclude or an include.
*
* @var bool
*/
protected $exclude = null;
/**
* @param [ string | array ] $properties The properties to exclude or include.
* @param bool $exclude If the method should be excluded
*/
public function __construct($properties, $exclude = true)
{
$this->exclude = $exclude;
$this->properties = is_array($properties)
? $properties
: [$properties];
}
public function filter($property)
{
return in_array($property, $this->properties)
? !$this->exclude
: $this->exclude;
}
}

190
src/App/Hydrator/Strategy/AbstractCollectionStrategy.php Normal file
View File

@ -0,0 +1,190 @@
<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace App\Hydrator\Strategy;
use InvalidArgumentException;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Zend\Hydrator\Strategy\StrategyInterface;
/**
* @license MIT
* @link http://www.doctrine-project.org/
* @since 0.7.0
* @author Michael Gallego <mic.gallego@gmail.com>
*/
abstract class AbstractCollectionStrategy implements StrategyInterface
{
/**
* @var string
*/
protected $collectionName;
/**
* @var ClassMetadata
*/
protected $metadata;
/**
* @var object
*/
protected $object;
/**
* Set the name of the collection
*
* @param string $collectionName
* @return AbstractCollectionStrategy
*/
public function setCollectionName($collectionName)
{
$this->collectionName = (string) $collectionName;
return $this;
}
/**
* Get the name of the collection
*
* @return string
*/
public function getCollectionName()
{
return $this->collectionName;
}
/**
* Set the class metadata
*
* @param ClassMetadata $classMetadata
* @return AbstractCollectionStrategy
*/
public function setClassMetadata(ClassMetadata $classMetadata)
{
$this->metadata = $classMetadata;
return $this;
}
/**
* Get the class metadata
*
* @return ClassMetadata
*/
public function getClassMetadata()
{
return $this->metadata;
}
/**
* Set the object
*
* @param object $object
*
* @throws \InvalidArgumentException
*
* @return AbstractCollectionStrategy
*/
public function setObject($object)
{
if (!is_object($object)) {
throw new InvalidArgumentException(
sprintf('The parameter given to setObject method of %s class is not an object', get_called_class())
);
}
$this->object = $object;
return $this;
}
/**
* Get the object
*
* @return object
*/
public function getObject()
{
return $this->object;
}
/**
* {@inheritDoc}
*/
public function extract($value)
{
return $value;
}
/**
* Return the collection by value (using the public API)
*
* @throws \InvalidArgumentException
*
* @return Collection
*/
protected function getCollectionFromObjectByValue()
{
$object = $this->getObject();
$getter = 'get' . ucfirst($this->getCollectionName());
if (!method_exists($object, $getter)) {
throw new InvalidArgumentException(
sprintf(
'The getter %s to access collection %s in object %s does not exist',
$getter,
$this->getCollectionName(),
get_class($object)
)
);
}
return $object->$getter();
}
/**
* Return the collection by reference (not using the public API)
*
* @return Collection
*/
protected function getCollectionFromObjectByReference()
{
$object = $this->getObject();
$refl = $this->getClassMetadata()->getReflectionClass();
$reflProperty = $refl->getProperty($this->getCollectionName());
$reflProperty->setAccessible(true);
return $reflProperty->getValue($object);
}
/**
* This method is used internally by array_udiff to check if two objects are equal, according to their
* SPL hash. This is needed because the native array_diff only compare strings
*
* @param object $a
* @param object $b
*
* @return int
*/
protected function compareObjects($a, $b)
{
return strcmp(spl_object_hash($a), spl_object_hash($b));
}
}

58
src/App/Hydrator/Strategy/AllowRemoveByReference.php Normal file
View File

@ -0,0 +1,58 @@
<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace App\Hydrator\Strategy;
/**
* When this strategy is used for Collections, if the new collection does not contain elements that are present in
* the original collection, then this strategy remove elements from the original collection. For instance, if the
* collection initially contains elements A and B, and that the new collection contains elements B and C, then the
* final collection will contain elements B and C (while element A will be asked to be removed).
*
* This strategy is by reference, this means it won't use public API to add/remove elements to the collection
*
* @license MIT
* @link http://www.doctrine-project.org/
* @since 0.7.0
* @author Michael Gallego <mic.gallego@gmail.com>
*/
class AllowRemoveByReference extends AbstractCollectionStrategy
{
/**
* {@inheritDoc}
*/
public function hydrate($value)
{
$collection = $this->getCollectionFromObjectByReference();
$collectionArray = $collection->toArray();
$toAdd = array_udiff($value, $collectionArray, [$this, 'compareObjects']);
$toRemove = array_udiff($collectionArray, $value, [$this, 'compareObjects']);
foreach ($toAdd as $element) {
$collection->add($element);
}
foreach ($toRemove as $element) {
$collection->removeElement($element);
}
return $collection;
}
}

76
src/App/Hydrator/Strategy/AllowRemoveByValue.php Normal file
View File

@ -0,0 +1,76 @@
<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace App\Hydrator\Strategy;
use Doctrine\Common\Collections\Collection;
use LogicException;
use Doctrine\Common\Collections\ArrayCollection;
/**
* When this strategy is used for Collections, if the new collection does not contain elements that are present in
* the original collection, then this strategy remove elements from the original collection. For instance, if the
* collection initially contains elements A and B, and that the new collection contains elements B and C, then the
* final collection will contain elements B and C (while element A will be asked to be removed).
*
* This strategy is by value, this means it will use the public API (in this case, adder and remover)
*
* @license MIT
* @link http://www.doctrine-project.org/
* @since 0.7.0
* @author Michael Gallego <mic.gallego@gmail.com>
*/
class AllowRemoveByValue extends AbstractCollectionStrategy
{
/**
* {@inheritDoc}
*/
public function hydrate($value)
{
// AllowRemove strategy need "adder" and "remover"
$adder = 'add' . ucfirst($this->collectionName);
$remover = 'remove' . ucfirst($this->collectionName);
if (!method_exists($this->object, $adder) || !method_exists($this->object, $remover)) {
throw new LogicException(
sprintf(
'AllowRemove strategy for DoctrineModule hydrator requires both %s and %s to be defined in %s
entity domain code, but one or both seem to be missing',
$adder,
$remover,
get_class($this->object)
)
);
}
$collection = $this->getCollectionFromObjectByValue();
if ($collection instanceof Collection) {
$collection = $collection->toArray();
}
$toAdd = new ArrayCollection(array_udiff($value, $collection, [$this, 'compareObjects']));
$toRemove = new ArrayCollection(array_udiff($collection, $value, [$this, 'compareObjects']));
$this->object->$adder($toAdd);
$this->object->$remover($toRemove);
return $collection;
}
}

53
src/App/Hydrator/Strategy/DisallowRemoveByReference.php Normal file
View File

@ -0,0 +1,53 @@
<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace App\Hydrator\Strategy;
/**
* When this strategy is used for Collections, if the new collection does not contain elements that are present in
* the original collection, then this strategy will not remove those elements. At most, it will add new elements. For
* instance, if the collection initially contains elements A and B, and that the new collection contains elements B
* and C, then the final collection will contain elements A, B and C.
*
* This strategy is by reference, this means it won't use the public API to remove elements
*
* @license MIT
* @link http://www.doctrine-project.org/
* @since 0.7.0
* @author Michael Gallego <mic.gallego@gmail.com>
*/
class DisallowRemoveByReference extends AbstractCollectionStrategy
{
/**
* {@inheritDoc}
*/
public function hydrate($value)
{
$collection = $this->getCollectionFromObjectByReference();
$collectionArray = $collection->toArray();
$toAdd = array_udiff($value, $collectionArray, [$this, 'compareObjects']);
foreach ($toAdd as $element) {
$collection->add($element);
}
return $collection;
}
}

72
src/App/Hydrator/Strategy/DisallowRemoveByValue.php Normal file
View File

@ -0,0 +1,72 @@
<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace App\Hydrator\Strategy;
use Doctrine\Common\Collections\Collection;
use LogicException;
use Doctrine\Common\Collections\ArrayCollection;
/**
* When this strategy is used for Collections, if the new collection does not contain elements that are present in
* the original collection, then this strategy will not remove those elements. At most, it will add new elements. For
* instance, if the collection initially contains elements A and B, and that the new collection contains elements B
* and C, then the final collection will contain elements A, B and C.
*
* This strategy is by value, this means it will use the public API (in this case, remover)
*
* @license MIT
* @link http://www.doctrine-project.org/
* @since 0.7.0
* @author Michael Gallego <mic.gallego@gmail.com>
*/
class DisallowRemoveByValue extends AbstractCollectionStrategy
{
/**
* {@inheritDoc}
*/
public function hydrate($value)
{
// AllowRemove strategy need "adder"
$adder = 'add' . ucfirst($this->collectionName);
if (!method_exists($this->object, $adder)) {
throw new LogicException(
sprintf(
'DisallowRemove strategy for DoctrineModule hydrator requires %s to
be defined in %s entity domain code, but it seems to be missing',
$adder,
get_class($this->object)
)
);
}
$collection = $this->getCollectionFromObjectByValue();
if ($collection instanceof Collection) {
$collection = $collection->toArray();
}
$toAdd = new ArrayCollection(array_udiff($value, $collection, [$this, 'compareObjects']));
$this->object->$adder($toAdd);
return $collection;
}
}

106
src/App/Service/GalleryService.php
View File

@ -4,6 +4,8 @@
namespace App\Service;
use App\Entity\Image;
use Doctrine\ORM\EntityManager;
use Imagine\Gd\Imagine;
use Imagine\Image\Box;
use Imagine\Image\ImageInterface;
@ -18,19 +20,29 @@ class GalleryService
const THUMBNAIL_SIZE = 500;
protected $contentTypeMap = [
'jpg' => 'image/jpeg',
'jpg' => 'image/jpeg',
'jpeg' => 'image/jpeg',
'png' => 'image/png',
'png' => 'image/png',
];
protected $config;
/**
* @var EntityManager
*/
protected $em;
public function __construct(EntityManager $entityManager)
{
$this->em = $entityManager;
}
public function loadGalleryData($includeHidden = false)
{
$config = $this->getConfig();
$slugs = [];
$albums = [];
foreach ($config['galleries'] as $id => $data) {
if ($includeHidden || $data['public']) {
$slugs[] = [
$albums[] = [
'slug' => $id,
'name' => $data['name'],
'coverImage' => isset($data['cover'])
@ -44,7 +56,7 @@ class GalleryService
];
}
}
return $slugs;
return $albums;
}
private function getGalleryDate(string $dir): string
@ -56,73 +68,53 @@ class GalleryService
/**
* @param string $dir
* @return array
* @return Image[]
* @todo implement label for image in some way
*/
private function loadGalleryImages(string $dir)
private function loadGalleryImages(string $dir): array
{
$images = array_map('basename', glob(
sprintf(self::IMAGE_BASEDIR . "*.{jpg,jpeg,png}", $dir),
GLOB_BRACE
));
return array_map(function ($image) {
return [
'label' => '',
$imagine = new Imagine();
return array_map(function ($image) use ($dir, $imagine) {
$imageEntity = $this->em->getRepository(Image::class)->findOneBy([
'dir' => $dir,
'path' => $image,
];
]);
if (null === $imageEntity) {
$imageEntity = new Image();
$imageEntity->setLabel("")
->setDir($dir)
->setPath($image);
$this->processImageSizes($dir, $imageEntity, $imagine);
$this->em->persist($imageEntity);
$this->em->flush();
}
return $imageEntity;
}, $images);
}
private function processImageSizes(string $dir, Image $image, Imagine $imagine)
{
$img = $imagine->open(sprintf(self::IMAGE_BASEDIR, $dir) . $image->getPath());
$imgSize = $img->getSize();
$image->setWidth($imgSize->getWidth())
->setHeight($imgSize->getHeight());
}
/**
* @param string $image
* @return array
* @return Image
*/
private function getCoverImage(string $image)
private function getCoverImage(string $image): Image
{
return [
'label' => '',
'path' => $image,
];
}
public function listGalleries($includeHidden = false)
{
$config = $this->getConfig();
$slugs = [];
foreach ($config['galleries'] as $id => $data) {
if ($includeHidden || $data['public']) {
$slugs[] = [
'id' => $id,
'label' => $data['name'],
'new' => $data['new'],
];
}
}
return $slugs;
}
public function getGallery(string $slug)
{
$galleryList = $this->listGalleries(true);
$slugs = array_map(function ($item) {
return $item['id'];
}, $galleryList);
$config = $this->getConfig();
$images = [];
if (in_array($slug, $slugs)) {
$dir = $config['galleries'][$slug]['dir'];
$images = array_map('basename', glob(
sprintf(self::IMAGE_BASEDIR . "*.{jpg,jpeg,png}", $dir),
GLOB_BRACE
));
}
return [
'name' => $config['galleries'][$slug]['name'],
'type' => $config['galleries'][$slug]['type'],
'images' => $images,
];
$img = new Image();
return $img->setLabel("")
->setPath($image)
->setWidth(0)
->setHeight(0);
}
public function getImage(string $slug, string $image, $size = false): string

14
src/App/Service/GalleryServiceFactory.php Normal file
View File

@ -0,0 +1,14 @@
<?php
namespace App\Service;
use Interop\Container\ContainerInterface;
class GalleryServiceFactory
{
public function __invoke(ContainerInterface $container)
{
$galleryService = $container->get('doctrine.entity_manager.orm_default');
return new GalleryService($galleryService);
}
}