/**
* @param int $calendarId
*
* @return array
*/
public function getItems($calendarId)
{
$selectItems = [];
$intCasts = [];
$metadata = $this->getMetadata();
$fields = $this->getFields();
foreach ($fields as $fieldName => $fieldType) {
$underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldType);
if ($this->fieldTypeHelper->isRelation($underlyingFieldType)) {
$selectItems[] = sprintf('IDENTITY(o.%1$s) AS %1$s', $fieldName);
if ($metadata->hasAssociation($fieldName)) {
$assocType = $this->doctrineHelper->getSingleEntityIdentifierFieldType($metadata->getAssociationTargetClass($fieldName), false);
if ($assocType === 'integer') {
$intCasts[] = $fieldName;
}
}
} else {
$selectItems[] = 'o.' . $fieldName;
}
}
$repo = $this->doctrineHelper->getEntityRepository(self::CALENDAR_PROPERTY_CLASS);
$qb = $repo->createQueryBuilder('o')->select(implode(',', $selectItems))->where('o.targetCalendar = :calendar_id')->setParameter('calendar_id', $calendarId)->orderBy('o.id');
$result = $qb->getQuery()->getArrayResult();
// normalize integer foreign keys due Doctrine IDENTITY function always returns a string
if ($intCasts) {
foreach ($result as &$item) {
foreach ($intCasts as $fieldName) {
if (isset($item[$fieldName]) && is_string($item[$fieldName])) {
$item[$fieldName] = (int) $item[$fieldName];
}
}
}
}
return $result;
}
/**
* Adds entity fields to $result
*
* @param array $result
* @param string $className
* @param bool $applyExclusions
* @param bool $translate
*/
protected function addFields(array &$result, $className, $applyExclusions, $translate)
{
$metadata = $this->getMetadataFor($className);
// add regular fields
$configs = $this->extendConfigProvider->getConfigs($className);
foreach ($configs as $fieldConfig) {
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $fieldConfig->getId();
$fieldName = $fieldConfigId->getFieldName();
$fieldType = $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType());
if ($this->fieldTypeHelper->isRelation($fieldType)) {
// skip because this field is relation
continue;
}
if (isset($result[$fieldName])) {
// skip because a field with this name is already added, it could be a virtual field
continue;
}
if (!$this->entityConfigProvider->hasConfig($className, $fieldName)) {
// skip non configurable field
continue;
}
if ($this->isIgnoredField($metadata, $fieldName)) {
continue;
}
if ($fieldConfig->is('is_deleted')) {
continue;
}
if ($applyExclusions && $this->exclusionProvider->isIgnoredField($metadata, $fieldName)) {
continue;
}
$this->addField($result, $fieldName, $fieldConfigId->getFieldType(), $this->getFieldLabel($metadata, $fieldName), $metadata->isIdentifier($fieldName), $translate);
}
}
/**
* Determines whether the index for the given field is needed or not.
* All relation type fields should be excluded.
* Index requirement is determined by visibility of a field on a grid.
*
* @param string $className
* @param string $fieldName
* @param string $fieldType
*
* @return bool
*/
protected function isIndexRequired($className, $fieldName, $fieldType)
{
$underlyingType = $this->fieldTypeHelper->getUnderlyingType($fieldType);
if (!$this->fieldTypeHelper->isRelation($underlyingType)) {
$datagridConfigProvider = $this->configManager->getProvider('datagrid');
if ($datagridConfigProvider->hasConfig($className, $fieldName)) {
$datagridConfig = $datagridConfigProvider->getConfig($className, $fieldName);
return $datagridConfig->get('is_visible', false, false);
}
}
return false;
}
/**
* @param string $columnName
* @param array $options
* @param string $className
* @param Table $table
*/
protected function buildIndex($columnName, $options, $className, $table)
{
$columnType = $this->fieldTypeHelper->getUnderlyingType($options[ExtendOptionsManager::TYPE_OPTION]);
if ($this->fieldTypeHelper->isRelation($columnType) || in_array($columnType, [Type::TEXT])) {
return;
}
$indexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $columnName);
if ($this->isEnabled($options) && $this->isExtended($options) && !$table->hasIndex($indexName)) {
$table->addIndex([$columnName], $indexName);
} elseif (!$this->isEnabled($options) && $table->hasIndex($indexName)) {
$table->dropIndex($indexName);
}
}
/**
* Return "false" if can't find config for field, "null" if field type is unknown for given field
* or array with config data for given field
*
* @param ClassMetadata $metadata
* @param $field
* @return array|bool
*/
protected function guessAttributeParametersScalarField(ClassMetadata $metadata, $field)
{
if ($metadata->hasField($field)) {
$doctrineType = $metadata->getTypeOfField($field);
if (!isset($this->doctrineTypeMapping[$doctrineType])) {
return null;
}
return $this->formatResult($this->getLabel($metadata->getName(), $field), $this->doctrineTypeMapping[$doctrineType]['type'], $this->doctrineTypeMapping[$doctrineType]['options']);
} elseif ($this->entityConfigProvider->hasConfig($metadata->getName(), $field)) {
$entityConfig = $this->entityConfigProvider->getConfig($metadata->getName(), $field);
$fieldType = $entityConfig->getId()->getFieldType();
if (!FieldTypeHelper::isRelation($fieldType)) {
return $this->formatResult($entityConfig->get('label'), $this->doctrineTypeMapping[$fieldType]['type'], $this->doctrineTypeMapping[$fieldType]['options']);
}
}
return false;
}
/**
* @dataProvider relationCHeckTestProvider
*/
public function testIsRelation($fieldType, $expected)
{
$this->assertSame($expected, FieldTypeHelper::isRelation($fieldType));
}
