/**
* {@inheritdoc}
*/
protected function getFields(DatagridConfiguration $config)
{
$entityClassName = $this->entityClassResolver->getEntityClass($this->getEntityName($config));
if (!$this->configManager->hasConfig($entityClassName)) {
return [];
}
$entityConfigProvider = $this->configManager->getProvider('entity');
$extendConfigProvider = $this->configManager->getProvider('extend');
$viewConfigProvider = $this->configManager->getProvider('view');
$datagridConfigProvider = $this->configManager->getProvider('datagrid');
$fields = [];
$fieldIds = $entityConfigProvider->getIds($entityClassName);
/** @var FieldConfigId $fieldId */
foreach ($fieldIds as $fieldId) {
$extendConfig = $extendConfigProvider->getConfigById($fieldId);
if ($extendConfig->is('owner', ExtendScope::OWNER_CUSTOM) && ExtendHelper::isFieldAccessible($extendConfig) && $datagridConfigProvider->getConfigById($fieldId)->is('is_visible')) {
$viewConfig = $viewConfigProvider->getConfig($entityClassName, $fieldId->getFieldName());
$fields[] = ['id' => $fieldId, 'priority' => $viewConfig->get('priority', false, 0)];
}
}
ArrayUtil::sortBy($fields, true);
return array_map(function ($field) {
return $field['id'];
}, $fields);
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if (!$this->isApplicable($options)) {
return;
}
$className = $options['data_class'];
$extendConfigProvider = $this->configManager->getProvider('extend');
$viewConfigProvider = $this->configManager->getProvider('view');
$fields = [];
$formConfigs = $this->configManager->getProvider('form')->getConfigs($className);
foreach ($formConfigs as $formConfig) {
if (!$formConfig->is('is_enabled')) {
continue;
}
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $formConfig->getId();
$fieldName = $fieldConfigId->getFieldName();
$extendConfig = $extendConfigProvider->getConfig($className, $fieldName);
if (!$this->isApplicableField($extendConfig, $extendConfigProvider)) {
continue;
}
$fields[$fieldName] = ['priority' => $viewConfigProvider->getConfig($className, $fieldName)->get('priority', false, 0)];
}
ArrayUtil::sortBy($fields, true);
foreach ($fields as $fieldName => $priority) {
$builder->add($fieldName);
}
}
/**
* Sorts items by a value of "position" attribute
*
* @param array $items The array to be processed
*/
protected function sortItemsByPosition(array &$items)
{
ArrayUtil::sortBy($items, false, 'position');
foreach ($items as &$item) {
unset($item['position']);
}
}
/**
* Sorts the routes by priority
*/
public function sortByPriority()
{
$routes = $this->all();
ArrayUtil::sortBy($routes, false, function (Route $route) {
return $route->getOption('priority') ?: 0;
});
$this->setRoutes($routes);
}
/**
* Sorts an array by specified property.
*
* This method uses the stable sorting algorithm. See http://en.wikipedia.org/wiki/Sorting_algorithm#Stability
*
* Supported options:
* property [string] The path of the property by which the array should be sorted. Defaults to 'priority'
* reverse [boolean] Indicates whether the sorting should be performed in reverse order. Defaults to FALSE
* sorting-type [string] number, string or string-case (for case-insensitive sorting). Defaults to 'number'
*
* @param array $array The array to be sorted
* @param array $options The sorting options
*
* @return array The sorted array
*/
public function sortBy(array $array, array $options = [])
{
$sortingType = self::getOption($options, 'sorting-type', 'number');
if ($sortingType === 'number') {
$sortingFlags = SORT_NUMERIC;
} else {
$sortingFlags = SORT_STRING;
if ($sortingType === 'string-case') {
$sortingFlags |= SORT_FLAG_CASE;
}
}
ArrayUtil::sortBy($array, self::getOption($options, 'reverse', false), self::getOption($options, 'property', 'priority'), $sortingFlags);
return $array;
}
/**
* @param object $entity
* @param null|string $entityClass
* @return array
*/
public function getFields($entity, $entityClass = null)
{
$dynamicRow = [];
if (null === $entityClass) {
$entityClass = ClassUtils::getRealClass($entity);
}
$fields = $this->extendProvider->filter([$this, 'filterFields'], $entityClass);
foreach ($fields as $field) {
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $field->getId();
$fieldName = $fieldConfigId->getFieldName();
$fieldType = $fieldConfigId->getFieldType();
$value = $this->propertyAccessor->getValue($entity, $fieldName);
$event = new ValueRenderEvent($entity, $value, $fieldConfigId);
$this->eventDispatcher->dispatch(EntityExtendEvents::BEFORE_VALUE_RENDER, $event);
$fieldConfig = $this->entityProvider->getConfigById($fieldConfigId);
$dynamicRow[$fieldName] = ['type' => $fieldType, 'label' => $fieldConfig->get('label') ?: $fieldName, 'value' => $event->getFieldViewValue(), 'priority' => $this->viewProvider->getConfigById($fieldConfigId)->get('priority', false, 0)];
}
ArrayUtil::sortBy($dynamicRow, true);
foreach ($dynamicRow as &$row) {
unset($row['priority']);
}
return $dynamicRow;
}
/**
* Sorts the given items by 'order' attribute
*
* @param array $items
* @return mixed
*/
protected function sortItems($items)
{
ArrayUtil::sortBy($items, false, 'order');
return array_keys($items);
}
protected function sortSubBlocks()
{
ArrayUtil::sortBy($this->subBlocks, true);
}
public function testSortByCallable()
{
$obj1 = $this->createObject(['name' => '1', 'priority' => null]);
$obj2 = $this->createObject(['name' => '2', 'priority' => 100]);
$obj3 = $this->createObject(['name' => '3', 'priority' => 0]);
$array = [$obj1, $obj2, $obj3];
ArrayUtil::sortBy($array, false, [$this, 'getObjectPriority']);
$this->assertSame([$obj1, $obj3, $obj2], $array);
}
/**
* @param ConnectorInterface[] $connectors
* @return ConnectorInterface[]
*/
protected function getSortedConnectors(array $connectors)
{
$sortCallback = function ($connector) {
return $connector instanceof OrderedConnectorInterface ? $connector->getOrder() : OrderedConnectorInterface::DEFAULT_ORDER;
};
ArrayUtil::sortBy($connectors, false, $sortCallback);
return $connectors;
}
/**
* @return array|StrategyInterface[]
*/
protected function getElements()
{
if (!$this->ordered) {
ArrayUtil::sortBy($this->elements, true, static::PRIORITY_KEY);
$this->ordered = true;
}
return $this->elements;
}
/**
* Sorts an array by specified property.
*
* This method uses the stable sorting algorithm. See http://en.wikipedia.org/wiki/Sorting_algorithm#Stability
* Please use this method only if you really need stable sorting because this method is not so fast
* as native PHP sort functions.
*
* @param array $array The array to be sorted
* @param bool $reverse Indicates whether the sorting should be performed
* in reverse order
* @param string|PropertyPathInterface $propertyPath The path of the property by which the array should be sorted
* @param int $sortingFlags The sorting type. Can be SORT_NUMERIC or SORT_STRING
* Also SORT_STRING can be combined with SORT_FLAG_CASE to sort
* strings case-insensitively
*
* @deprecated since 1.9. Use Oro\Component\PhpUtils\ArrayUtil::sortBy instead
*/
public static function sortBy(array &$array, $reverse = false, $propertyPath = 'priority', $sortingFlags = SORT_NUMERIC)
{
ArrayUtil::sortBy($array, $reverse, $propertyPath, $sortingFlags);
}
/**
* @param array $calendars
*/
protected function normalizeCalendarData(array &$calendars)
{
// apply default values and remove redundant properties
$defaultValues = $this->getCalendarDefaultValues();
foreach ($calendars as &$calendar) {
$this->applyCalendarDefaultValues($calendar, $defaultValues);
}
ArrayUtil::sortBy($calendars, false, 'position');
}
