Programming Language PHP

Namespace Oro\Component\PhpUtils

Class ArrayUtil

Method/Function sortBy

Total Examples 31

31 code examples of PHP Oro\Component\PhpUtils\ArrayUtil::sortBy extracted from open source projects

Was this example useful?
0
                                                    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
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByClosure()
    {
        $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,
            function ($item) {
                return $item->priority;
            }
        );
        $this->assertSame(
            [
                $obj1,
                $obj3,
                $obj2,
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByObjectPath()
    {
        $obj1 = $this->createObject(
            ['name' => '1', 'child' => $this->createObject(['priority' => null])]
        );
        $obj2 = $this->createObject(
            ['name' => '2', 'child' => $this->createObject(['priority' => 100])]
        );
        $obj3 = $this->createObject(
            ['name' => '3', 'child' => $this->createObject(['priority' => 0])]
        );
        $array = [
            $obj1,
            $obj2,
            $obj3,
        ];

        ArrayUtil::sortBy($array, false, 'child.priority');
        $this->assertSame(
            [
                $obj1,
                $obj3,
                $obj2,
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByObject()
    {
        $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);
        $this->assertSame(
            [
                $obj1,
                $obj3,
                $obj2,
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayPath()
    {
        $array = [
            ['name' => '1', 'child' => ['priority' => 1]],
            ['name' => '2', 'child' => ['priority' => 3]],
            ['name' => '3', 'child' => ['priority' => 2]],
        ];

        ArrayUtil::sortBy($array, false, '[child][priority]');
        $this->assertSame(
            [
                ['name' => '1', 'child' => ['priority' => 1]],
                ['name' => '3', 'child' => ['priority' => 2]],
                ['name' => '2', 'child' => ['priority' => 3]],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayStringCaseInsensitiveReverse()
    {
        $array = [
            ['name' => 'a'],
            ['name' => 'C'],
            ['name' => 'B'],
        ];

        ArrayUtil::sortBy($array, true, 'name', SORT_STRING | SORT_FLAG_CASE);
        $this->assertSame(
            [
                ['name' => 'C'],
                ['name' => 'B'],
                ['name' => 'a'],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayStringCaseInsensitive()
    {
        $array = [
            ['name' => 'a'],
            ['name' => 'C'],
            ['name' => 'B'],
        ];

        ArrayUtil::sortBy($array, false, 'name', SORT_STRING | SORT_FLAG_CASE);
        $this->assertSame(
            [
                ['name' => 'a'],
                ['name' => 'B'],
                ['name' => 'C'],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayStringReverse()
    {
        $array = [
            ['name' => 'a'],
            ['name' => 'c'],
            ['name' => 'b'],
        ];

        ArrayUtil::sortBy($array, true, 'name', SORT_STRING);
        $this->assertSame(
            [
                ['name' => 'c'],
                ['name' => 'b'],
                ['name' => 'a'],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayString()
    {
        $array = [
            ['name' => 'a'],
            ['name' => 'c'],
            ['name' => 'b'],
        ];

        ArrayUtil::sortBy($array, false, 'name', SORT_STRING);
        $this->assertSame(
            [
                ['name' => 'a'],
                ['name' => 'b'],
                ['name' => 'c'],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByAssocArrayNumericReverse()
    {
        $array = [
            'i1' => ['name' => '1'],
            'i2' => ['name' => '2'],
            'i3' => ['name' => '3', 'priority' => 100],
            'i4' => ['name' => '4'],
            'i5' => ['name' => '5', 'priority' => -100],
            'i6' => ['name' => '6', 'priority' => 100],
            'i7' => ['name' => '7', 'priority' => -100],
            'i8' => ['name' => '8', 'priority' => 0],
            'i9' => ['name' => '9'],
        ];

        ArrayUtil::sortBy($array, true);
        $this->assertSame(
            [
                'i3' => ['name' => '3', 'priority' => 100],
                'i6' => ['name' => '6', 'priority' => 100],
                'i1' => ['name' => '1'],
                'i2' => ['name' => '2'],
                'i4' => ['name' => '4'],
                'i8' => ['name' => '8', 'priority' => 0],
                'i9' => ['name' => '9'],
                'i5' => ['name' => '5', 'priority' => -100],
                'i7' => ['name' => '7', 'priority' => -100],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByAssocArrayNumeric()
    {
        $array = [
            'i1' => ['name' => '1'],
            'i2' => ['name' => '2'],
            'i3' => ['name' => '3', 'priority' => 100],
            'i4' => ['name' => '4'],
            'i5' => ['name' => '5', 'priority' => -100],
            'i6' => ['name' => '6', 'priority' => 100],
            'i7' => ['name' => '7', 'priority' => -100],
            'i8' => ['name' => '8', 'priority' => 0],
            'i9' => ['name' => '9'],
        ];

        ArrayUtil::sortBy($array);
        $this->assertSame(
            [
                'i5' => ['name' => '5', 'priority' => -100],
                'i7' => ['name' => '7', 'priority' => -100],
                'i1' => ['name' => '1'],
                'i2' => ['name' => '2'],
                'i4' => ['name' => '4'],
                'i8' => ['name' => '8', 'priority' => 0],
                'i9' => ['name' => '9'],
                'i3' => ['name' => '3', 'priority' => 100],
                'i6' => ['name' => '6', 'priority' => 100],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayNumericReverse()
    {
        $array = [
            ['name' => '1'],
            ['name' => '2'],
            ['name' => '3', 'priority' => 100],
            ['name' => '4'],
            ['name' => '5', 'priority' => -100],
            ['name' => '6', 'priority' => 100],
            ['name' => '7', 'priority' => -100],
            ['name' => '8', 'priority' => 0],
            ['name' => '9'],
        ];

        ArrayUtil::sortBy($array, true);
        $this->assertSame(
            [
                ['name' => '3', 'priority' => 100],
                ['name' => '6', 'priority' => 100],
                ['name' => '1'],
                ['name' => '2'],
                ['name' => '4'],
                ['name' => '8', 'priority' => 0],
                ['name' => '9'],
                ['name' => '5', 'priority' => -100],
                ['name' => '7', 'priority' => -100],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayNumeric()
    {
        $array = [
            ['name' => '1'],
            ['name' => '2'],
            ['name' => '3', 'priority' => 100],
            ['name' => '4'],
            ['name' => '5', 'priority' => -100],
            ['name' => '6', 'priority' => 100],
            ['name' => '7', 'priority' => -100],
            ['name' => '8', 'priority' => 0],
            ['name' => '9'],
        ];

        ArrayUtil::sortBy($array);
        $this->assertSame(
            [
                ['name' => '5', 'priority' => -100],
                ['name' => '7', 'priority' => -100],
                ['name' => '1'],
                ['name' => '2'],
                ['name' => '4'],
                ['name' => '8', 'priority' => 0],
                ['name' => '9'],
                ['name' => '3', 'priority' => 100],
                ['name' => '6', 'priority' => 100],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArraySameOrderReverse()
    {
        $array = [
            ['name' => '1', 'priority' => 100],
            ['name' => '2', 'priority' => 100],
            ['name' => '3', 'priority' => 100],
        ];

        ArrayUtil::sortBy($array, true);
        $this->assertSame(
            [
                ['name' => '1', 'priority' => 100],
                ['name' => '2', 'priority' => 100],
                ['name' => '3', 'priority' => 100],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArraySameOrder()
    {
        $array = [
            ['name' => '1', 'priority' => 100],
            ['name' => '2', 'priority' => 100],
            ['name' => '3', 'priority' => 100],
        ];

        ArrayUtil::sortBy($array);
        $this->assertSame(
            [
                ['name' => '1', 'priority' => 100],
                ['name' => '2', 'priority' => 100],
                ['name' => '3', 'priority' => 100],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayNoOrderReverse()
    {
        $array = [
            ['name' => '1'],
            ['name' => '2'],
            ['name' => '3'],
        ];

        ArrayUtil::sortBy($array, true);
        $this->assertSame(
            [
                ['name' => '1'],
                ['name' => '2'],
                ['name' => '3'],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByArrayNoOrder()
    {
        $array = [
            ['name' => '1'],
            ['name' => '2'],
            ['name' => '3'],
        ];

        ArrayUtil::sortBy($array);
        $this->assertSame(
            [
                ['name' => '1'],
                ['name' => '2'],
                ['name' => '3'],
            ],
            $array
        );
    }
                                            
Was this example useful?
0
                                                    public function testSortByEmpty()
    {
        $array = [];

        ArrayUtil::sortBy($array);
        $this->assertSame([], $array);
    }
                                            
Was this example useful?
0
                                                    /**
     * @depends testWorkflowDefinitionPost
     */
    public function testWorkflowDefinitionGet()
    {
        $workflow = $this->getDefinition(self::TEST_DEFINITION_NAME);
        $this->assertInstanceOf(Workflow::class, $workflow);
        $workflowDefinition = $workflow->getDefinition();

        $this->client->jsonRequest(
            'GET',
            $this->getUrl(
                'oro_api_workflow_definition_get',
                ['workflowDefinition' => self::TEST_DEFINITION_NAME]
            )
        );
        $result = $this->getJsonResponseContent($this->client->getResponse(), 200);

        $expectedWorkflowDefinitionConfiguration = $workflowDefinition->getConfiguration();
        unset(
            $expectedWorkflowDefinitionConfiguration['acl_message'],
            $expectedWorkflowDefinitionConfiguration['page_template'],
            $expectedWorkflowDefinitionConfiguration['dialog_template']
        );
        $transitionId = key($expectedWorkflowDefinitionConfiguration['transitions']);
        unset(
            $expectedWorkflowDefinitionConfiguration['transitions'][$transitionId]['acl_message'],
            $expectedWorkflowDefinitionConfiguration['transitions'][$transitionId]['page_template'],
            $expectedWorkflowDefinitionConfiguration['transitions'][$transitionId]['dialog_template']
        );
        $expectedWorkflowDefinitionSteps = [];
        foreach ($workflowDefinition->getSteps() as $step) {
            $expectedWorkflowDefinitionSteps[] = [
                'id' => $step->getId(),
                'name' => $step->getName(),
                'label' => $step->getLabel(),
                'step_order' => $step->getStepOrder(),
                'final' => $step->isFinal(),
            ];
        }
        $expectedResult = [
            'name' => $workflowDefinition->getName(),
            'label' => $workflowDefinition->getLabel(),
            'related_entity' => $workflowDefinition->getRelatedEntity(),
            'entity_attribute_name' => $workflowDefinition->getEntityAttributeName(),
            'steps_display_ordered' => $workflowDefinition->isStepsDisplayOrdered(),
            'system' => $workflowDefinition->isSystem(),
            'active' => $workflowDefinition->isActive(),
            'priority' => $workflowDefinition->getPriority(),
            'configuration' => $expectedWorkflowDefinitionConfiguration,
            'scopes' => [],
            'steps' => $expectedWorkflowDefinitionSteps,
            'entity_acls' => [],
            'exclusive_active_groups' => [],
            'exclusive_record_groups' => [],
            'applications' => $workflowDefinition->getApplications(),
        ];

        $this->assertArrayHasKey('created_at', $result);
        $this->assertArrayHasKey('updated_at', $result);
        unset($result['created_at'], $result['updated_at']);

        ArrayUtil::sortBy($expectedResult['steps'], false, 'step_order');
        ArrayUtil::sortBy($result['steps'], false, 'step_order');
        $this->assertEquals($expectedResult, $result);
    }
                                            
Was this example useful?
0
                                                    /**
     * 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 = []): array
    {
        $sortingType = $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,
            $options['reverse'] ?? false,
            $options['property'] ?? 'priority',
            $sortingFlags
        );

        return $array;
    }
                                            
Was this example useful?
0
                                                    /**
     * @param ConnectorInterface[] $connectors
     *
     * @return ConnectorInterface[]
     */
    protected function getSortedConnectors(array $connectors): array
    {
        $sortCallback = function ($connector) {
            return $connector instanceof OrderedConnectorInterface
                ? $connector->getOrder()
                : OrderedConnectorInterface::DEFAULT_ORDER;
        };
        ArrayUtil::sortBy($connectors, false, $sortCallback);

        return $connectors;
    }
                                            
Was this example useful?
0
                                                    protected function sortBlocks()
    {
        ArrayUtil::sortBy($this->blocks, true);
    }
                                            
Was this example useful?
0
                                                    protected function sortSubBlocks()
    {
        ArrayUtil::sortBy($this->subBlocks, true);
    }
                                            
Was this example useful?
0
                                                    /**
     * @inheritdoc
     */
    public function getFields($entity, $entityClass = null)
    {
        if (null === $entityClass) {
            $entityClass = ClassUtils::getRealClass($entity);
        }

        $dynamicRows = [];
        $fields = $this->getExtendConfigProvider()->getConfigs($entityClass);
        foreach ($fields as $field) {
            if ($this->filterFields($field)) {
                /** @var FieldConfigId $fieldConfigId */
                $fieldConfigId = $field->getId();
                $fieldName = $fieldConfigId->getFieldName();
                $row = $this->createDynamicFieldRow($fieldConfigId, $fieldName, $entity);
                if ($row) {
                    $dynamicRows[$fieldName] = $row;
                }
            }
        }

        ArrayUtil::sortBy($dynamicRows, true);
        foreach ($dynamicRows as &$row) {
            unset($row['priority']);
        }

        return $dynamicRows;
    }
                                            
Was this example useful?
0
                                                    /**
     * @return FieldConfigId[]
     */
    public function getFields(string $entityClassName): array
    {
        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);
            $fieldConfig = $datagridConfigProvider->getConfigById($fieldId);

            if ($this->isApplicableField($extendConfig, $fieldConfig)) {
                $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
        );
    }
                                            
Was this example useful?
0
                                                    public function preSetData(PreSetDataEvent $event): void
    {
        $form = $event->getForm();
        $className = $form->getConfig()->getOption('data_class');

        $extendConfigProvider = $this->configManager->getProvider('extend');
        $viewConfigProvider = $this->configManager->getProvider('view');
        $attributeConfigProvider = $this->configManager->getProvider('attribute');

        $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();

            $attributeConfig = $attributeConfigProvider->getConfig($className, $fieldName);
            if ($attributeConfig->is('is_attribute')) {
                continue;
            }

            $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) {
            if (!$this->fieldExists($form, $fieldName)) {
                $form->add($fieldName, null, ['is_dynamic_field' => true]);
            }
        }
    }
                                            
Was this example useful?
0
                                                    /**
     * Get ordered widgets for column
     */
    public function getOrderedColumnWidgets(int $column, bool $appendGreater = false, bool $appendLesser = false): array
    {
        $elements = $this->widgets->filter(
            function ($element) use ($column, $appendGreater, $appendLesser) {
                /** @var WidgetModel $element */
                $actualColumn = current($element->getLayoutPosition());

                return
                    ($actualColumn == $column) ||
                    ($appendGreater && $actualColumn > $column) ||
                    ($appendLesser && $actualColumn < $column);
            }
        );

        $result = $elements->getValues();
        /**
         * We had to use stable sort to make UI consistent
         * independent of php version
         */
        ArrayUtil::sortBy($result, false, 'layout_position');

        return $result;
    }
                                            
Was this example useful?
0
                                                    private function sortItemsByPosition(array &$items): void
    {
        ArrayUtil::sortBy($items, false, self::POSITION);
        foreach ($items as &$item) {
            unset($item[self::POSITION]);
        }
    }
                                            
Was this example useful?
0
                                                    /**
     * Resort children array
     */
    public function resort(): void
    {
        ArrayUtil::sortBy($this->children, true);
    }
                                            
Was this example useful?
0
                                                    /**
     * @param array $items [[service id, expression], ...]
     *
     * @return array [[service id, expression], ...]
     */
    private function sortByRequestTypeExpression(array $items): array
    {
        ArrayUtil::sortBy(
            $items,
            true,
            function ($item) {
                $result = 0;
                $expression = $item[1];
                if ($expression) {
                    $result = 100;
                    $aspects = explode('&', $expression);
                    foreach ($aspects as $aspect) {
                        $result += $this->getRequestTypeAspectRank($aspect);
                    }
                }

                return $result;
            }
        );

        return $items;
    }
                                            
Was this example useful?
0
                                                    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');
    }