/**
* @param \Twig_Environment $environment
* @param FieldableEntity $entity
* @param string $field
*
* @return string
* @internal param \Twig_Environment $environment
*/
public function renderFieldDisplay(\Twig_Environment $environment, FieldableEntity $entity, $field)
{
$class = get_class($entity);
$displayMapping = $this->displayManager->getEntityConfig($class);
$fieldSettings = $this->fieldManager->getEntityFieldMapping($class);
$html = '';
if ($displayMapping['options']['fields'][$field]) {
$displayFieldSettings = $displayMapping['options']['fields'][$field] + ['type' => null, 'label' => true, 'label_inline' => false, 'options' => []];
$display = $this->displayManager->getDisplayDefinition($displayFieldSettings['type']);
$fieldEntity = call_user_func([$entity, 'get' . $field]);
$fieldDisplayOptions = $displayFieldSettings['options'] ?: [];
$templateOptions = ['entity' => $fieldEntity, 'field_settings' => $fieldSettings, 'field_name' => $field, 'label' => is_string($displayFieldSettings['label']) ?: ($displayFieldSettings['label'] ? $field : false), 'label_inline' => $displayFieldSettings['label_inline']];
if ($fieldSettings[$field]['options']['limit'] > 1) {
$subHtml = '';
$subTemplateOptions = $templateOptions;
$subTemplateOptions['label'] = false;
foreach ($fieldEntity as $fieldEntityItem) {
$subHtml .= $environment->render($display->getTemplate(), $subTemplateOptions + $display->getTemplateOptions($fieldEntityItem, $fieldDisplayOptions));
}
$templateOptions['rows'] = $subHtml;
$html = $environment->render($display->getListTemplate(), $templateOptions + $display->getListTemplateOptions($fieldEntity, $fieldDisplayOptions));
} else {
$html = $environment->render($display->getTemplate(), $templateOptions + $display->getTemplateOptions($fieldEntity, $fieldDisplayOptions));
}
}
return $html;
}
public function requireFieldAssets()
{
$assets = [];
foreach ($this->fieldManager->getFieldWidgetDefinitions() as $definition) {
foreach ($definition->getAssetLibraries() as $library) {
$assets = array_merge($assets, $library->getJavascripts());
}
}
return $assets;
}
/**
* {@inheritdoc}
*/
public function getGlobals()
{
$fieldWidgets = $this->fieldManager->getFieldWidgetDefinitions();
$javascripts = [];
$stylesheets = [];
foreach ($fieldWidgets as $fieldWidget) {
$fieldWidgetAssetLibs = $fieldWidget->getAssetLibraries();
foreach ($fieldWidgetAssetLibs as $fieldWidgetAssetLib) {
$javascripts = array_merge($javascripts, $fieldWidgetAssetLib->getJavascripts());
$stylesheets = array_merge($stylesheets, $fieldWidgetAssetLib->getStylesheets());
}
}
return ['field_assets_js' => $javascripts, 'field_assets_css' => $stylesheets];
}
/**
* @inheritDoc
*/
public function shouldSkipClass(ClassMetadata $metadata, Context $context)
{
if ($this->fieldManager->hasEntityFieldMapping($metadata->name)) {
return false;
}
if ($metadata->reflection->isSubclassOf('Gravity\\CmsBundle\\Entity\\Field')) {
return false;
}
if ($metadata->reflection->isSubclassOf('Gravity\\CmsBundle\\Entity\\FieldableEntity')) {
return false;
}
if ($metadata->reflection->implementsInterface('Symfony\\Component\\Security\\Core\\User\\UserInterface')) {
return false;
}
return $this->otherStrategy->shouldSkipClass($metadata, $context);
}
/**
* {@inheritDoc}
*/
public function getOptions($term, array $options)
{
$fieldSearch = ['vocab' => [], 'terms' => ['name' => $term]];
$fieldDefinitions = $this->fieldManager->getEntityFieldMapping($options['class']);
foreach ($fieldDefinitions as $fieldName => $fieldDefinition) {
if ($fieldDefinition['searchable']) {
$fieldSearch['terms'][$fieldName] = $term;
}
}
/** @var Tag[] $taxonomies */
$taxonomies = $this->searchAdaptor->search($options['class'], $fieldSearch, $options['page_size'], $options['page_offset']);
$tagOptions = [];
foreach ($taxonomies as $taxonomy) {
$tagOptions[] = ['text' => (string) $taxonomy, 'id' => $taxonomy->getId()];
}
if ($options['allow_new']) {
$tagOptions[] = ['text' => $term, 'id' => $term];
}
return $tagOptions;
}
/**
* @param LoadClassMetadataEventArgs $eventArgs
*/
public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs)
{
// the $metadata is the whole mapping info for this class
/** @var \Doctrine\ORM\Mapping\ClassMetadata $metadata */
$metadata = $eventArgs->getClassMetadata();
$reflection = $metadata->getReflectionClass();
if (!isset($this->entityMappings[$metadata->getName()])) {
return;
}
// map all the user fields automatically if they aren't defined
if (!$metadata->hasAssociation('createdBy')) {
$metadata->mapManyToOne(['fieldName' => 'createdBy', 'targetEntity' => $this->userEntity]);
}
if (!$metadata->hasAssociation('editedBy')) {
$metadata->mapManyToOne(['fieldName' => 'editedBy', 'targetEntity' => $this->userEntity]);
}
if (!$metadata->hasAssociation('deletedBy')) {
$metadata->mapManyToOne(['fieldName' => 'deletedBy', 'targetEntity' => $this->userEntity]);
}
$entityManager = $eventArgs->getEntityManager();
$namingStrategy = $entityManager->getConfiguration()->getNamingStrategy();
foreach ($this->entityMappings[$metadata->getName()] as $field => $fieldConfig) {
$fieldDefinition = $this->fieldManager->getFieldDefinition($fieldConfig['type']);
if ($fieldConfig['dynamic']) {
if ($fieldConfig['options']['limit'] > 1) {
$mapping = ['targetEntity' => $fieldDefinition->getEntityClass(), 'fieldName' => $field, 'cascade' => ['persist'], 'joinTable' => ['name' => strtolower($namingStrategy->classToTableName($metadata->getName())) . '_field_' . $namingStrategy->propertyToColumnName($field)], 'orderBy' => ['delta' => 'ASC'], 'unique' => false];
} else {
$mapping = ['targetEntity' => $fieldDefinition->getEntityClass(), 'fieldName' => $field, 'cascade' => ['persist'], 'unique' => false];
}
$event = new FieldMappingEvent($entityManager, $fieldDefinition, $metadata, $field, $fieldConfig, $mapping);
$this->eventDispatcher->dispatch(GravityEvents::FIELD_MAPPING, $event);
if ($fieldConfig['options']['limit'] > 1) {
$metadata->mapManyToMany($event->getMapping());
} else {
$metadata->mapManyToOne($event->getMapping());
}
}
}
}
/**
* @param FormMapper $formMapper
*/
protected function configureFormFields(FormMapper $formMapper)
{
$formMapper->with('Content', ['class' => 'col-md-9'])->end()->with('Publishing', ['class' => 'col-md-3'])->end()->with('Routing', ['class' => 'col-md-3'])->add('path', 'text', ['required' => false])->end();
$fieldMappings = $this->fieldManager->getEntityFieldMapping($this->getClass());
$formMapper->with('Content');
foreach ($fieldMappings as $field => $settings) {
$fieldDefinition = $this->fieldManager->getFieldDefinition($settings['type']);
$fieldWidgetDefinition = $this->fieldManager->getFieldWidgetDefinition($settings['widget']['type']);
$constraints = $fieldDefinition->getConstraints($field, $settings['options']);
// TODO: deprecate dynamic
if ($settings['dynamic']) {
$fieldWidgetDefinition->configureForm($formMapper, $fieldDefinition, $field, $settings['options'], $settings['widget']['type'], $settings['widget']['options']);
$formMapper->getFormBuilder()->addEventListener(FormEvents::POST_SET_DATA, function (FormEvent $formEvent) use($fieldDefinition, $field, $settings) {
$data = $formEvent->getData();
if ($data instanceof Node) {
$value = $data->{"get{$field}"}();
if (!$value || !count($value) && $settings['options']['limit'] == 1) {
$fieldClass = $fieldDefinition->getEntityClass();
if ($fieldClass) {
$data->{"set{$field}"}(new $fieldClass());
}
}
}
});
} else {
$fieldWidgetDefinition->configureForm($formMapper, $fieldDefinition, $field, $settings['options'], $settings['widget']['type'], $settings['widget']['options']);
/** @var ClassMetadata $metadata */
$metadata = $this->validator->getMetadataFactory()->getMetadataFor($this->getClass());
foreach ($constraints as $constraintField => $constraint) {
$metadata->addPropertyConstraints($constraintField, $constraint);
}
}
}
$formMapper->end();
$formMapper->end();
}
