/** * Recursively parse all metadata for a class * * @param string $className Class to get all metadata for * @param array $visited Classes we've already visited to prevent infinite recursion. * @param array $groups Serialization groups to include. * @return array metadata for given class * @throws \InvalidArgumentException */ protected function doParse($className, $visited = array(), array $groups = array()) { $meta = $this->factory->getMetadataForClass($className); if (null === $meta) { throw new \InvalidArgumentException(sprintf("No metadata found for class %s", $className)); } $exclusionStrategies = array(); $exclusionStrategies[] = new GroupsExclusionStrategy($groups); $params = array(); // iterate over property metadata foreach ($meta->propertyMetadata as $item) { if (!is_null($item->type)) { $name = $this->namingStrategy->translateName($item); $dataType = $this->processDataType($item); // apply exclusion strategies foreach ($exclusionStrategies as $strategy) { if (true === $strategy->shouldSkipProperty($item, SerializationContext::create())) { continue 2; } } $params[$name] = array('dataType' => $dataType['normalized'], 'required' => false, 'description' => $this->getDescription($className, $item), 'readonly' => $item->readOnly, 'sinceVersion' => $item->sinceVersion, 'untilVersion' => $item->untilVersion); // if class already parsed, continue, to avoid infinite recursion if (in_array($dataType['class'], $visited)) { continue; } // check for nested classes with JMS metadata if ($dataType['class'] && null !== $this->factory->getMetadataForClass($dataType['class'])) { $visited[] = $dataType['class']; $params[$name]['children'] = $this->doParse($dataType['class'], $visited, $groups); } } } return $params; }
/** * @param LifecycleEventArgs $ea */ public function prePersist(LifecycleEventArgs $ea) { $entity = $ea->getEntity(); foreach ($this->metadataFactory->getMetadataForClass(get_class($entity))->propertyMetadata as $file) { $this->mogrify($entity, $file); } }
/** * {@inheritdoc} */ public function parse($input) { $meta = $this->factory->getMetadataForClass($input); if (null === $meta) { throw new \InvalidArgumentException(sprintf("No metadata found for class %s", $input)); } $params = array(); //iterate over property metadata foreach ($meta->propertyMetadata as $item) { if (!is_null($item->type)) { $name = isset($item->serializedName) ? $item->serializedName : $item->name; $dataType = $this->processDataType(is_string($item->type) ? $item->type : $item->type['name']); $params[$name] = array('dataType' => $dataType['normalized'], 'required' => false, 'description' => $this->getDescription($input, $item), 'readonly' => $item->readOnly); // if class already parsed, continue, to avoid infinite recursion if (in_array($dataType['class'], $this->parsedClasses)) { continue; } //check for nested classes with JMS metadata if ($dataType['class'] && null !== $this->factory->getMetadataForClass($dataType['class'])) { $this->parsedClasses[] = $dataType['class']; $params[$name]['children'] = $this->parse($dataType['class']); } } } $this->parsedClasses = array(); return $params; }
/** * Recursively parse all metadata for a class * * @param string $className Class to get all metadata for * @param array $visited Classes we've already visited to prevent infinite recursion. * @param array $groups Serialization groups to include. * @return array metadata for given class * @throws \InvalidArgumentException */ protected function doParse($className, $visited = array(), array $groups = array()) { $meta = $this->factory->getMetadataForClass($className); if (null === $meta) { throw new \InvalidArgumentException(sprintf("No metadata found for class %s", $className)); } $exclusionStrategies = array(); if ($groups) { $exclusionStrategies[] = new GroupsExclusionStrategy($groups); } $params = array(); $reflection = new \ReflectionClass($className); $defaultProperties = array_map(function ($default) { if (is_array($default) && count($default) === 0) { return null; } return $default; }, $reflection->getDefaultProperties()); // iterate over property metadata foreach ($meta->propertyMetadata as $item) { if (!is_null($item->type)) { $name = $this->namingStrategy->translateName($item); $dataType = $this->processDataType($item); // apply exclusion strategies foreach ($exclusionStrategies as $strategy) { if (true === $strategy->shouldSkipProperty($item, SerializationContext::create())) { $params[$name] = null; continue 2; } } if (!$dataType['inline']) { $params[$name] = array('dataType' => $dataType['normalized'], 'actualType' => $dataType['actualType'], 'subType' => $dataType['class'], 'required' => false, 'default' => isset($defaultProperties[$item->name]) ? $defaultProperties[$item->name] : null, 'description' => $this->getDescription($item), 'readonly' => $item->readOnly, 'sinceVersion' => $item->sinceVersion, 'untilVersion' => $item->untilVersion); if (!is_null($dataType['class']) && false === $dataType['primitive']) { $params[$name]['class'] = $dataType['class']; } } // we can use type property also for custom handlers, then we don't have here real class name if (!class_exists($dataType['class'])) { continue; } // if class already parsed, continue, to avoid infinite recursion if (in_array($dataType['class'], $visited)) { continue; } // check for nested classes with JMS metadata if ($dataType['class'] && false === $dataType['primitive'] && null !== $this->factory->getMetadataForClass($dataType['class'])) { $visited[] = $dataType['class']; $children = $this->doParse($dataType['class'], $visited, $groups); if ($dataType['inline']) { $params = array_merge($params, $children); } else { $params[$name]['children'] = $children; } } } } return $params; }
/** * @param object $object * * @return Relation[] */ public function getRelations($object) { $relations = array(); if (null !== ($classMetadata = $this->metadataFactory->getMetadataForClass(get_class($object)))) { $relations = array_merge($relations, $classMetadata->getRelations()); } $relations = array_merge($relations, $this->relationProvider->getRelations($object)); return $relations; }
/** * {@inheritDoc} */ public function setUp() { self::bootKernel(); $this->container = static::$kernel->getContainer(); $this->application = new Application(static::$kernel); $this->application->setAutoExit(false); $this->application->setCatchExceptions(false); $this->metadataFactory = $this->container->get('abc.job.metadata_factory'); /** @var ClassMetadata $classMetadata */ $this->classMetadata = $this->metadataFactory->getMetadataForClass(AnnotatedJob::class)->getRootClassMetadata(); }
/** * {@inheritDoc} */ public function getInheritPathForClass($objectOrClass) { $class = is_object($objectOrClass) ? get_class($objectOrClass) : $objectOrClass; if (!is_string($class)) { throw new \InvalidArgumentException('Expected object or string.'); } if (null === ($m = $this->metadataFactory->getMetadataForClass($class))) { throw new \RuntimeException(sprintf('No characteristics metadata found for class "%s".', $class)); } return $m->inherit; }
/** * {@inheritdoc} */ public function getType($type) { if (parent::hasType($type)) { return parent::getType($type); } $metadata = $this->metadataFactory->getMetadataForClass($type); if (!$metadata) { throw new \InvalidArgumentException(sprintf('The type "%s" cannot be loaded by this extension', $type)); } $surrogateType = new SurrogateType($type, $this->fieldRegistry, $metadata); return $surrogateType; }
private function getElementName($data, Embed $embed = null) { $elementName = null; if (null !== $embed) { $elementName = $embed->getXmlElementName(); } if (null == $elementName && is_object($data)) { $metadata = $this->metadataFactory->getMetadataForClass(ClassUtils::getClass($data)); $elementName = $metadata->xmlRootName; } return $elementName ?: 'entry'; }
/** * @param MethodInvocation $method * @return mixed * @throws \Exception * @throws RuntimeException * @throws AuthenticationCredentialsNotFoundException * @throws AccessDeniedException */ public function intercept(MethodInvocation $method) { $metadata = $this->metadataFactory->getMetadataForClass($method->reflection->class); // no security metadata, proceed if (empty($metadata) || !isset($metadata->methodMetadata[$method->reflection->name])) { return $method->proceed(); } $metadata = $metadata->methodMetadata[$method->reflection->name]; if (null === ($token = $this->tokenStorage->getToken())) { throw new AuthenticationCredentialsNotFoundException('The TokenStorage was not populated with a Token.'); } if ($this->alwaysAuthenticate || !$token->isAuthenticated()) { $token = $this->authenticationManager->authenticate($token); $this->tokenStorage->setToken($token); } if (!empty($metadata->roles) && false === $this->accessDecisionManager->decide($token, $metadata->roles, $method)) { throw new AccessDeniedException('Token does not have the required roles.'); } if (!empty($metadata->paramPermissions)) { foreach ($method->arguments as $index => $argument) { if (null !== $argument && isset($metadata->paramPermissions[$index]) && false === $this->accessDecisionManager->decide($token, $metadata->paramPermissions[$index], $argument)) { throw new AccessDeniedException(sprintf('Token does not have the required permissions for method "%s::%s".', $method->reflection->class, $method->reflection->name)); } } } $runAsToken = null; if (!empty($metadata->runAsRoles)) { $runAsToken = $this->runAsManager->buildRunAs($token, $method, $metadata->runAsRoles); if (null !== $this->logger) { $this->logger->debug('Populating TokenStorage with RunAsToken'); } if (null === $runAsToken) { throw new RuntimeException('RunAsManager must not return null from buildRunAs().'); } $this->tokenStorage->setToken($runAsToken); } try { $returnValue = $method->proceed(); if (null !== $runAsToken) { $this->restoreOriginalToken($runAsToken); } if (empty($metadata->returnPermissions)) { return $returnValue; } return $this->afterInvocationManager->decide($this->tokenStorage->getToken(), $method, $metadata->returnPermissions, $returnValue); } catch (\Exception $failed) { if (null !== $runAsToken) { $this->restoreOriginalToken($runAsToken); } throw $failed; } }
public function addRelations($object, ClassMetadataInterface $classMetadata) { // @todo fix hateoas metadata to include serializer metadata $metadata = $this->metadataFactory->getMetadataForClass($classMetadata->name); $relations = []; foreach ($metadata->propertyMetadata as $propertyName => $propertyMetadata) { if ($this->isPropertyDTO($propertyMetadata->type, $object->{$propertyName})) { $route = null; $relations[] = new Hateoas\Relation($propertyName, $route, new Hateoas\Embedded('expr(object.' . $propertyName . ')')); } } return $relations; }
/** * @param JobTypeInterface $jobType * @param bool $loadClassMetadata Whether to load class metadata of the job class */ public function register(JobTypeInterface $jobType, $loadClassMetadata = false) { if ($loadClassMetadata) { /** * @var ClassMetadata $classMetadata */ $classMetadata = $this->metadataFactory->getMetadataForClass($jobType->getClass())->getRootClassMetadata(); $jobType->setParameterTypes($classMetadata->getParameterTypes($jobType->getMethod())); $jobType->setParameterTypeOptions($classMetadata->getParameterOptions($jobType->getMethod())); $jobType->setReturnType($classMetadata->getReturnType($jobType->getMethod())); $jobType->setReturnTypeOptions($classMetadata->getReturnOptions($jobType->getMethod())); } $jobType->setQueue($this->queueConfig->getQueue($jobType->getName())); $this->types[$jobType->getName()] = $jobType; }
/** * {@inheritdoc} */ public function shouldSkipProperty(PropertyMetadata $property, Context $context) { if (!$context instanceof SerializationContext) { return false; } /** @var \Mango\Bundle\JsonApiBundle\Configuration\Metadata\ClassMetadata $metadata */ $metadata = $this->metadataFactory->getMetadataForClass(get_class($context->getObject())); if ($metadata) { foreach ($metadata->getRelationships() as $relationship) { if ($property->name === $relationship->getName()) { return true; } } } return false; }
/** * @param $object * @param Relationship $relationship * @param Context $context * * @return array */ protected function processRelationship($object, Relationship $relationship, Context $context) { if (null === $object) { return null; } if (!is_object($object)) { throw new \RuntimeException(sprintf('Cannot process relationship "%s", because it is not an object but a %s.', $relationship->getName(), gettype($object))); } /** @var ClassMetadata $relationshipMetadata */ $relationshipMetadata = $this->hateoasMetadataFactory->getMetadataForClass(get_class($object)); if (null === $relationshipMetadata) { throw new \RuntimeException(sprintf('Metadata for class %s not found. Did you define at as a JSON-API resource?', ClassUtils::getRealClass(get_class($object)))); } $relationshipId = $this->getId($relationshipMetadata, $object); // contains the relations type and id $relationshipDataArray = $this->getRelationshipDataArray($relationshipMetadata, $relationshipId); // only include this relationship if it is needed if ($relationship->isIncludedByDefault() && $this->canIncludeRelationship($relationshipMetadata, $relationshipId)) { $includedRelationship = $relationshipDataArray; // copy data array so we do not override it with our reference $this->includedRelationships[] =& $includedRelationship; $includedRelationship = $context->accept($object); // override previous reference with the serialized data } // the relationship data can only contain one reference to another resource return $relationshipDataArray; }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { $serializerMetadata = $this->metadataFactory->getMetadataForClass($this->class); $manager = $this->registry->getManagerForClass($this->class); $doctrineMetadata = $manager->getClassMetadata($this->class); foreach ($serializerMetadata->propertyMetadata as $propertyMetadata) { $name = $propertyMetadata->name; if (in_array($name, $doctrineMetadata->getIdentifierFieldNames()) && !$this->identifierOverwrite) { continue; } if (!in_array($this->group, $propertyMetadata->groups)) { continue; } $type = null; $nullable = true; if (isset($doctrineMetadata->fieldMappings[$name])) { $fieldMetadata = $doctrineMetadata->fieldMappings[$name]; $type = isset($fieldMetadata['type']) ? $fieldMetadata['type'] : null; $nullable = isset($fieldMetadata['nullable']) ? $fieldMetadata['nullable'] : false; } else { if (isset($doctrineMetadata->associationMappings[$name])) { $associationMetadata = $doctrineMetadata->associationMappings[$name]; if (isset($associationMetadata['joinColumns']['nullable'])) { $nullable = $associationMetadata['joinColumns']['nullable']; } else { if (isset($associationMetadata['inverseJoinColumns']['nullable'])) { $nullable = $associationMetadata['inverseJoinColumns']['nullable']; } } } } switch ($type) { case 'datetime': $builder->add($name, $type, array('required' => !$nullable, 'widget' => 'single_text')); break; case 'boolean': $childBuilder = $builder->create($name, null, array('required' => !$nullable)); $childBuilder->addEventSubscriber(new FixCheckboxDataListener()); $builder->add($childBuilder); break; default: $builder->add($name, null, array('required' => !$nullable)); break; } } }
/** * Populates an empty UriContextCollection with UriContexts. * * @param $uriContextCollection UriContextCollection */ public function build(UriContextCollection $uriContextCollection) { $subjectObject = $uriContextCollection->getSubjectObject(); $realClassName = $this->adapter->getRealClassName(get_class($subjectObject)); $metadata = $this->metadataFactory->getMetadataForClass($realClassName); // TODO: This is where we will call $metadata->getUriSchemas() which will return an // array of URI schemas (inc. the "template", TP configs and CR configs). $definitions = $metadata->getAutoRouteDefinitions(); foreach ($definitions as $definition) { $locales = $this->adapter->getLocales($subjectObject) ?: array(null); foreach ($locales as $locale) { // create and add uri context to stack $uriContext = $uriContextCollection->createUriContext($definition->getUriSchema(), $definition->getDefaults(), $metadata->getTokenProviders(), $metadata->getConflictResolver(), $locale); $uriContextCollection->addUriContext($uriContext); } } }
/** * @param $class * @return ClassMetadata|null */ protected function getMetadata($class) { if (array_key_exists($class, $this->metadata)) { return $this->metadata[$class]; } if (!class_exists($class)) { $this->metadata[$class] = null; return null; } /** @var ClassMetadata $classMetadata */ $classMetadata = $this->metadataFactory->getMetadataForClass($class); if (!$classMetadata->isForm()) { $this->metadata[$class] = null; return null; } $this->metadata[$class] = $classMetadata; return $classMetadata; }
public function testRegisterLoadsMetadata() { $callable = array(new TestJob(), 'log'); $jobType = new JobType('service-id', 'type', $callable, Logger::ERROR); $classHierarchyMetadata = $this->getMockBuilder(ClassHierarchyMetadata::class)->disableOriginalConstructor()->getMock(); $classMetadata = $this->getMockBuilder(ClassMetadata::class)->disableOriginalConstructor()->getMock(); $this->metadataFactory->expects($this->once())->method('getMetadataForClass')->with(get_class($callable[0]))->willReturn($classHierarchyMetadata); $classHierarchyMetadata->expects($this->once())->method('getRootClassMetadata')->willReturn($classMetadata); $classMetadata->expects($this->once())->method('getParameterTypes')->willReturn(['ParameterTypes']); $classMetadata->expects($this->once())->method('getParameterOptions')->willReturn(['ParameterTypeOptions']); $classMetadata->expects($this->once())->method('getReturnType')->willReturn('ReturnType'); $classMetadata->expects($this->once())->method('getReturnOptions')->willReturn(['ReturnTypeOptions']); $this->subject->register($jobType, true); $this->assertSame($jobType, $this->subject->get($jobType->getName())); $this->assertEquals(['ParameterTypes'], $jobType->getParameterTypes()); $this->assertEquals(['ParameterTypeOptions'], $jobType->getParameterTypeOptions()); $this->assertEquals('ReturnType', $jobType->getReturnType()); $this->assertEquals(['ReturnTypeOptions'], $jobType->getReturnTypeOptions()); }
/** * @param string $service * @return array|null */ private function findServiceConfig($service) { if (!isset($this->services[$service])) { foreach ($this->services as $sc) { if ($sc[2] === $service) { return $sc; } } foreach ($this->services as $sc) { $metadata = $this->metadataFactory->getMetadataForClass($sc[0]); if ($metadata instanceof ActionMetadata && $metadata->isAction && $metadata->alias === $service) { return $sc; } } } else { return $this->services[$service]; } return null; }
/** * Check if the given variable is a valid JSON-API resource. * * @param $data * * @return bool */ protected function isResource($data) { if (is_object($data)) { /** @var JsonApiClassMetadata $metadata */ if ($metadata = $this->metadataFactory->getMetadataForClass(get_class($data))) { if ($metadata->getResource()) { return true; } } } return false; }
public function getRelations($object) { $classMetadata = $this->metadataFactory->getMetadataForClass(get_class($object)); if (!$classMetadata instanceof ClassMetadataInterface) { return array(); } $relations = array(); foreach ($classMetadata->getRelationProviders() as $configuration) { if (null === ($relationProviderCallable = $this->resolver->getRelationProvider($configuration, $object))) { continue; } if (!is_callable($relationProviderCallable)) { throw new \RuntimeException('The returned relation provider is not callable, it should be.'); } $newRelations = call_user_func_array($relationProviderCallable, array($object, $classMetadata)); if (is_array($newRelations)) { $relations = array_merge($relations, $newRelations); } } return $relations; }
/** * Get item type of collection field * * @param string $className Class name * @param string $fieldName Field name * @return string|null */ private function getCollectionItemType($className, $fieldName) { $serializerMetadata = $this->serializerMetadataFactory->getMetadataForClass($className); if ($serializerMetadata === null) { return null; } if (!isset($serializerMetadata->propertyMetadata[$fieldName])) { return null; } $type = $serializerMetadata->propertyMetadata[$fieldName]->type; return isset($type['name'], $type['params'][0]['name']) && $type['name'] === 'array' ? $type['params'][0]['name'] : null; }
/** * {@inheritdoc} */ public function parse($input) { $className = $input['class']; $meta = $this->factory->getMetadataForClass($className); if (null === $meta) { throw new \InvalidArgumentException(sprintf("No metadata found for class %s", $className)); } $groups = $input['groups']; $exclusionStrategies = array(); if (true) { $exclusionStrategies[] = new GroupsExclusionStrategy($groups); } $params = array(); //iterate over property metadata foreach ($meta->propertyMetadata as $item) { if (!is_null($item->type)) { $name = isset($item->serializedName) ? $item->serializedName : $item->name; $dataType = $this->processDataType($item->type); // apply exclusion strategies foreach ($exclusionStrategies as $strategy) { if (true === $strategy->shouldSkipProperty($item)) { continue 2; } } $params[$name] = array('dataType' => $dataType['normalized'], 'required' => false, 'description' => $this->getDescription($item), 'readonly' => $item->readOnly); // if class already parsed, continue, to avoid infinite recursion if (in_array($dataType['class'], $this->parsedClasses)) { continue; } //check for nested classes with JMS metadata if ($dataType['class'] && null !== $this->factory->getMetadataForClass($dataType['class'])) { $this->parsedClasses[] = $dataType['class']; $params[$name]['children'] = $this->parse(array_merge($dataType, array('groups' => $groups))); } } } $this->parsedClasses = array(); return $params; }
/** * Generate OpenGraph through metadata * * @param object $obj * @return OpenGraphInterface */ public function generate($obj) { if (!is_object($obj)) { throw new \InvalidArgumentException('OpenGraphGenerator::generate only accept object argument.'); } $openGraph = new OpenGraph(); $classType = get_class($obj); $metadata = $this->factory->getMetadataForClass($classType); if (is_array($metadata->namespaces)) { foreach ($metadata->namespaces as $namespace) { $openGraph->addNamespace($namespace->prefix, $namespace->uri); } } if (is_array($metadata->nodes)) { foreach ($metadata->nodes as $graphNode) { if (!empty($graphNode['node']->namespaceUri)) { $openGraph->addNamespace($graphNode['node']->namespace, $graphNode['node']->namespaceUri); } $openGraph->add($graphNode['node']->namespace, $graphNode['node']->tag, $graphNode['object']->getValue($obj)); } } return $openGraph; }
/** * Builds the authtorization mapping for the given $classname. * * @param string $classname */ private function buildRights($classname) { $metadatas = $this->metadataFactory->getMetadataForClass($classname); $reflection = new \ReflectionClass($classname); $this->rights[$classname] = array(); if (null !== $metadatas) { foreach ($metadatas->propertyMetadata as $propertyName => $propertyMetadata) { $propertyName = $this->cleanPropertyName($propertyName); $this->rights[$classname][$propertyName] = array(); if (false === $propertyMetadata->readOnly && $reflection->hasMethod($this->buildProperMethodName('set', $propertyName))) { $this->rights[$classname][$propertyName][] = 'replace'; } } } }
/** * @param object $object */ protected function addObjectConstraints($object) { $metadata = $this->metadataFactory->getMetadataForClass(get_class($object)); if ($metadata !== null) { /** @var ClassMetadata $classMetadata */ $classMetadata = $metadata->getRootClassMetadata(); foreach ($classMetadata->getPropertiesMetadata() as $propertyMetadata) { foreach ($propertyMetadata->getConstraints() as $group => $constraints) { $allOf = Assert::create(); foreach ($constraints as $constraint) { $allOf->addRules($constraint->getRules()); } $this->addConstraint(Assert::create()->attribute($propertyMetadata->getPropertyName(), $allOf), get_class($object), $group); } } } }
/** * rename extracted parameters with JMS metadata naming strategy * * @param array $parameters * @param array $input * @return array */ protected function renameJmsParameters($parameters, $input) { $result = []; foreach ($parameters as $name => $value) { $className = $input['class']; $meta = null; try { $meta = $this->factory->getMetadataForClass($className); } catch (\ReflectionException $e) { } if (isset($meta->propertyMetadata[$name])) { $name = $this->namingStrategy->translateName($meta->propertyMetadata[$name]); } $result[$name] = $value; } return $result; }
/** * {@inheritdoc} */ public function endVisitingObject(ClassMetadata $metadata, $data, array $type, Context $context) { $rs = parent::endVisitingObject($metadata, $data, $type, $context); /** @var JsonApiClassMetadata $jsonApiMetadata */ $jsonApiMetadata = $this->metadataFactory->getMetadataForClass(get_class($data)); if (null === $jsonApiMetadata) { return $rs; } $idField = $jsonApiMetadata->getIdField(); if (empty($rs)) { $rs = new \ArrayObject(); if (array() === $this->getRoot()) { $this->setRoot(clone $rs); } return $rs; } $result = array(); if (isset($rs['type'])) { $result['type'] = $rs['type']; } if (isset($rs[$idField])) { $result['id'] = $rs[$idField]; } $result['attributes'] = array_filter($rs, function ($key) use($idField) { switch ($key) { case $idField: case 'type': case 'relationships': case 'links': return false; } return true; }, ARRAY_FILTER_USE_KEY); if (isset($rs['relationships'])) { $result['relationships'] = $rs['relationships']; } if (isset($rs['links'])) { $result['links'] = $rs['links']; } return $result; }
/** * @param LifecycleEventArgs $args * @param string $event */ protected function handleEvent(LifecycleEventArgs $args, $event) { $object = $args->getObject(); $om = $args->getObjectManager(); $class = get_class($object); $classMetadata = $this->metadataFactory->getMetadataForClass($class); $classMetadataInfo = $om->getClassMetadata($class); $identifierFields = $classMetadataInfo->getIdentifierFieldNames(); foreach ($classMetadata->propertyMetadata as $propertyMetadata) { if ($propertyMetadata instanceof PropertyMetadata && count($propertyMetadata->slugFields)) { $hasIdentifierFields = count(array_intersect($identifierFields, $propertyMetadata->slugFields)) > 0; if ($event == 'prePersist' && $hasIdentifierFields || $event == 'postPersist' && !$hasIdentifierFields) { continue; // generate slug in another event } $slug = null; if ($event == 'preUpdate') { if ($args->hasChangedField($propertyMetadata->name)) { // generate custom slug $slug = $this->slugger->slugify($args->getNewValue($propertyMetadata->name), $propertyMetadata->slugSeparator); } elseif (null !== $propertyMetadata->getValue($object)) { continue; // no changes } } else { // generate custom slug $slug = $this->slugger->slugify($propertyMetadata->getValue($object), $propertyMetadata->slugSeparator); } if (!trim($slug)) { // generate slug from the sluggable fields $slug = $this->generateSlugFromMetadata($object, $propertyMetadata->slugFields, $propertyMetadata->slugSeparator); } $id = $event == 'preUpdate' && method_exists($object, 'getId') ? $object->getId() : null; // generate unique slug $slug = $this->generateUniqueSlug($om, $object, $propertyMetadata->name, $slug, $propertyMetadata->slugSeparator, $id); $propertyMetadata->setValue($object, $slug); $this->recomputeSingleObjectChangeSet($om, $object); } } }
/** * @param \Staffim\DTOBundle\DTO\Model\DTOInterface $modelObject * @return \Staffim\DTOBundle\Filterer\Metadata\PropertyMetadata */ private function getClassPropertyMetadata($modelObject) { return $this->metadataFactory->getMetadataForClass(get_class($modelObject))->getRootClassMetadata()->propertyMetadata; }