/** * 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']); } }
/** * @param string $datagridName * @param array $datagridDefinition * @param bool $recursion * * @return array */ public function resolve($datagridName, $datagridDefinition, $recursion = false) { foreach ($datagridDefinition as $key => $val) { if (is_array($val)) { $this->parentNode = $val; $datagridDefinition[$key] = $this->resolve($datagridName, $val, true); continue; } $val = $this->resolveSystemCall($datagridName, $key, $val); if (!$recursion && self::KEY_EXTENDS === $key) { // get parent grid definition, resolved $definition = $this->container->get('oro_datagrid.datagrid.manager')->getConfigurationForGrid($val); // merge them and remove extend directive $datagridDefinition = ArrayUtil::arrayMergeRecursiveDistinct($definition->toArray(), $datagridDefinition); unset($datagridDefinition['extends']); $datagridDefinition[self::KEY_EXTENDED_FROM] = isset($datagridDefinition[self::KEY_EXTENDED_FROM]) ? $datagridDefinition[self::KEY_EXTENDED_FROM] : []; $datagridDefinition[self::KEY_EXTENDED_FROM][] = $val; // run resolve again on merged grid definition $datagridDefinition = $this->resolve($val, $datagridDefinition); // break current loop cause we've just extended grid definition break; } $datagridDefinition[$key] = $val; } return $datagridDefinition; }
/** * {@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); } }
/** * @param AbstractQueryDesigner $value * @param GroupingConstraint|Constraint $constraint */ public function validate($value, Constraint $constraint) { $definition = json_decode($value->getDefinition(), true); if (empty($definition['columns'])) { return; } $columns = $definition['columns']; $aggregateColumns = array_filter($columns, function (array $column) { return !empty($column['func']); }); if (empty($aggregateColumns)) { return; } $groupingColumns = []; if (!empty($definition['grouping_columns'])) { $groupingColumns = $definition['grouping_columns']; } $groupingColumnNames = ArrayUtil::arrayColumn($groupingColumns, 'name'); $columnNames = ArrayUtil::arrayColumn($columns, 'name'); $columnNamesToCheck = array_diff($columnNames, ArrayUtil::arrayColumn($aggregateColumns, 'name')); $columnsToGroup = array_diff($columnNamesToCheck, $groupingColumnNames); if (empty($columnsToGroup)) { return; } $columnLabels = []; foreach ($columns as $column) { if (in_array($column['name'], $columnsToGroup)) { $columnLabels[] = $column['label']; } } $this->context->addViolation($this->translator->trans($constraint->message, ['%columns%' => implode(', ', $columnLabels)])); }
/** * {@inheritdoc} */ public function merge(FieldData $fieldData) { $entityData = $fieldData->getEntityData(); $masterEntity = $entityData->getMasterEntity(); $sourceEntity = $fieldData->getSourceEntity(); if ($masterEntity->getId() !== $sourceEntity->getId()) { $queryBuilder = $this->doctrineHelper->getEntityRepository('OroNoteBundle:Note')->getBaseAssociatedNotesQB(ClassUtils::getRealClass($masterEntity), $masterEntity->getId()); $notes = $queryBuilder->getQuery()->getResult(); if (!empty($notes)) { $entityManager = $this->doctrineHelper->getEntityManager(current($notes)); foreach ($notes as $note) { $entityManager->remove($note); } } $queryBuilder = $this->doctrineHelper->getEntityRepository('OroNoteBundle:Note')->getBaseAssociatedNotesQB(ClassUtils::getRealClass($masterEntity), $sourceEntity->getId()); $notes = $queryBuilder->getQuery()->getResult(); if (!empty($notes)) { foreach ($notes as $note) { $note->setTarget($masterEntity); } } $fieldMetadata = $fieldData->getMetadata(); $activityClass = $fieldMetadata->get('type'); $entityClass = ClassUtils::getRealClass($sourceEntity); $queryBuilder = $this->doctrineHelper->getEntityRepository(ActivityList::ENTITY_NAME)->getActivityListQueryBuilderByActivityClass($entityClass, $sourceEntity->getId(), $activityClass); $activityListItems = $queryBuilder->getQuery()->getResult(); $activityIds = ArrayUtil::arrayColumn($activityListItems, 'id'); $this->activityListManager->replaceActivityTargetWithPlainQuery($activityIds, $entityClass, $sourceEntity->getId(), $masterEntity->getId()); } }
/** * 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); }
/** * @param array $response * @param string $container * @param string|null $key * * @return array */ protected function getArrayData(array $response, $container, $key = null) { if (!empty($response[$container])) { if ($key) { return ArrayUtil::arrayColumn($response[$container], $key); } return $response[$container]; } return []; }
/** * 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; }
/** * Collect datagrid configurations files and pass them to the configuration provider * * @param ContainerBuilder $container */ protected function registerConfigFiles(ContainerBuilder $container) { if ($container->hasDefinition(self::PROVIDER_SERVICE_ID)) { $config = []; $configLoader = new CumulativeConfigLoader('oro_datagrid', new YamlCumulativeFileLoader('Resources/config/datagrid.yml')); $resources = $configLoader->load($container); foreach ($resources as $resource) { if (isset($resource->data[self::ROOT_PARAMETER]) && is_array($resource->data[self::ROOT_PARAMETER])) { $config = ArrayUtil::arrayMergeRecursiveDistinct($config, $resource->data[self::ROOT_PARAMETER]); } } $configProviderDef = $container->getDefinition(self::PROVIDER_SERVICE_ID); $configProviderDef->replaceArgument(0, $config); } }
/** * @param GroupNode $rootNode * * @return boolean */ protected function isValid(GroupNode $rootNode) { if ($rootNode->getType() !== GroupNode::TYPE_MIXED) { return true; } $types = array_map(function ($node) { if ($node instanceof GroupNode) { return $node->getType(); } return $node->isComputed() ? GroupNode::TYPE_COMPUTED : GroupNode::TYPE_UNCOMPUTED; }, $rootNode->getChildren()); if (in_array(GroupNode::TYPE_MIXED, $types)) { return false; } $computedTypes = ArrayUtil::dropWhile(function ($type) { return $type === GroupNode::TYPE_UNCOMPUTED; }, $types); return !in_array(GroupNode::TYPE_UNCOMPUTED, $computedTypes); }
/** * {@inheritdoc} */ public function merge(FieldData $fieldData) { $entityData = $fieldData->getEntityData(); $masterEntity = $entityData->getMasterEntity(); $fieldMetadata = $fieldData->getMetadata(); $entities = $fieldData->getEntityData()->getEntities(); foreach ($entities as $sourceEntity) { if ($sourceEntity->getId() !== $masterEntity->getId()) { $entityClass = ClassUtils::getRealClass($masterEntity); $activityClass = $fieldMetadata->get('type'); $queryBuilder = $this->doctrineHelper->getEntityRepository(ActivityList::ENTITY_NAME)->getActivityListQueryBuilderByActivityClass($entityClass, $sourceEntity->getId(), $activityClass); $activityListItems = $queryBuilder->getQuery()->getResult(); $activityIds = ArrayUtil::arrayColumn($activityListItems, 'id'); $this->activityListManager->replaceActivityTargetWithPlainQuery($activityIds, $entityClass, $sourceEntity->getId(), $masterEntity->getId()); $activityIds = ArrayUtil::arrayColumn($activityListItems, 'relatedActivityId'); $this->activityListManager->replaceActivityTargetWithPlainQuery($activityIds, $entityClass, $sourceEntity->getId(), $masterEntity->getId(), $activityClass); } } }
/** * @param DataInterface $data * @param array $chartOptions * * @return DataInterface */ public function transform(DataInterface $data, array $chartOptions) { $this->initialize($data, $chartOptions); if (!$data->toArray()) { return new ArrayData([]); } $keys = array_unique(ArrayUtil::arrayColumn($this->sourceData, $this->groupingOption)); $values = array_combine($keys, array_fill(0, sizeof($keys), $this->getLabels())); foreach ($values as $group => &$value) { array_walk($value, function (&$label) use($group) { $counts = array_map(function ($item) use($label, $group) { if ($item[$this->groupingOption] == $group && $item[$this->labelKey] == $label) { return $item[$this->valueKey]; } return 0; }, $this->sourceData); $label = ['label' => $label, 'value' => array_sum($counts)]; }); } return new ArrayData($values); }
/** * @param DatagridConfiguration $configuration * @param string $gridName * * @return DatagridConfiguration */ public function extendConfiguration(DatagridConfiguration $configuration, $gridName) { $gridConfiguration = $this->configurationProvider->getConfiguration($gridName); $basicAlias = $configuration->offsetGetByPath('[source][query][from][0][alias]'); foreach ($this->pathsToFix as $path) { $forFix = $gridConfiguration->offsetGetByPath($path); if ($forFix) { $gridConfiguration->offsetSetByPath($path, $this->fixMixinAlias($basicAlias, $forFix)); } } $scopes = array_diff(array_keys($gridConfiguration->getIterator()->getArrayCopy()), ['name']); foreach ($scopes as $scope) { $path = sprintf('[%s]', $scope); $additionalParams = $gridConfiguration->offsetGetByPath($path); $baseParams = $configuration->offsetGetByPath($path, []); if (!is_array($additionalParams) || !is_array($baseParams)) { continue; } $configuration->offsetSetByPath($path, ArrayUtil::arrayMergeRecursiveDistinct($baseParams, $additionalParams)); } return $configuration; }
/** * {@inheritdoc} */ public function merge(FieldData $fieldData) { $entityData = $fieldData->getEntityData(); $masterEntity = $entityData->getMasterEntity(); $sourceEntity = $fieldData->getSourceEntity(); if ($masterEntity->getId() !== $sourceEntity->getId()) { $fieldMetadata = $fieldData->getMetadata(); $activityClass = $fieldMetadata->get('type'); $activityListItems = $this->getActivitiesByEntity($masterEntity, $activityClass); $activityIds = ArrayUtil::arrayColumn($activityListItems, 'relatedActivityId'); $activities = $this->doctrineHelper->getEntityRepository($activityClass)->findBy(['id' => $activityIds]); foreach ($activities as $activity) { $this->activityManager->removeActivityTarget($activity, $masterEntity); } $activityListItems = $this->getActivitiesByEntity($sourceEntity, $activityClass); $activityIds = ArrayUtil::arrayColumn($activityListItems, 'id'); $entityClass = ClassUtils::getRealClass($masterEntity); $this->activityListManager->replaceActivityTargetWithPlainQuery($activityIds, $entityClass, $sourceEntity->getId(), $masterEntity->getId()); $activityIds = ArrayUtil::arrayColumn($activityListItems, 'relatedActivityId'); $this->activityListManager->replaceActivityTargetWithPlainQuery($activityIds, $entityClass, $sourceEntity->getId(), $masterEntity->getId(), $activityClass); } }
/** * @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; }
/** * @return string */ protected function getUserOwnerFieldName() { return $this->emailOwnerProviderStorage->getEmailOwnerFieldName(ArrayUtil::find(function (EmailOwnerProviderInterface $provider) { return $provider->getEmailOwnerClass() === 'Oro\\Bundle\\UserBundle\\Entity\\User'; }, $this->emailOwnerProviderStorage->getProviders())); }
/** * Merge configuration into one config * * @param ContainerBuilder $container * @param string $name * @param array $config * * @throws \RuntimeException */ private function mergeConfigIntoOne(ContainerBuilder $container, $name, array $config = []) { if (!$container instanceof ExtendedContainerBuilder) { throw new \RuntimeException(sprintf('%s is expected to be passed into OroPlatformExtension', 'Oro\\Component\\DependencyInjection\\ExtendedContainerBuilder')); } $originalConfig = $container->getExtensionConfig($name); if (!count($originalConfig)) { $originalConfig[] = array(); } $mergedConfig = ArrayUtil::arrayMergeRecursiveDistinct($originalConfig[0], $config); $originalConfig[0] = $mergedConfig; $container->setExtensionConfig($name, $originalConfig); }
protected function sortSubBlocks() { ArrayUtil::sortBy($this->subBlocks, true); }
/** * Walk recursively through the tree, completing block definition in tree by found correspondent data "items" list * * @param array $actions * @param mixed $currentSubTree * @param string $parentId * @param array $items */ protected function processTree(array &$actions, $currentSubTree, $parentId, array $items) { if (!is_array($currentSubTree)) { return; } foreach ($currentSubTree as $k => $subtree) { $blockId = is_numeric($k) && is_string($subtree) ? $subtree : $k; if (!isset($items[$blockId])) { throw new \LogicException(sprintf('Item with id "%s" not found in items list', $blockId)); } $itemDefinition = $items[$blockId]; if (ArrayUtil::isAssoc($itemDefinition)) { // merge associative values to arguments $itemDefinition = array_merge($itemDefinition, ['id' => $blockId, 'parentId' => $parentId]); } else { // prepend blockId and parentId to arguments array_unshift($itemDefinition, $blockId, $parentId); } $actions[] = [self::ACTION_ADD => $itemDefinition]; $this->processTree($actions, $subtree, $blockId, $items); } }
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); }
/** * 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 EmailModel $emailModel * @param EmailTemplate $template * @param Email $email */ protected function applyTemplate(EmailModel $emailModel, EmailTemplate $template, Email $email) { $locales = array_merge($email->getAcceptedLocales(), [$this->defaultLocale]); $flippedLocales = array_flip($locales); $translatedSubjects = []; $translatedContents = []; foreach ($template->getTranslations() as $translation) { switch ($translation->getField()) { case 'content': $translatedContents[$translation->getLocale()] = $translation->getContent(); break; case 'subject': $translatedSubjects[$translation->getLocale()] = $translation->getContent(); break; } } $comparator = ArrayUtil::createOrderedComparator($flippedLocales); uksort($translatedSubjects, $comparator); uksort($translatedContents, $comparator); $validContents = array_intersect_key($translatedContents, $flippedLocales); $validsubjects = array_intersect_key($translatedSubjects, $flippedLocales); $content = reset($validContents); $subject = reset($validsubjects); $emailModel->setSubject($subject === false ? $template->getSubject() : $subject)->setBody($content === false ? $template->getContent() : $content)->setType($template->getType()); }
/** * @param string $entity * @return array */ protected function getEntityLevelContactInfoColumns($entity) { $contactInfoColumns = array(); if ($this->configProvider->hasConfig($entity)) { $entityContactInformation = $this->configProvider->getConfig($entity)->get('contact_information'); if ($entityContactInformation) { foreach ($entityContactInformation as $contactInfoType => $contactInfoFields) { $entityColumns = ArrayUtil::arrayColumn($contactInfoFields, 'fieldName'); foreach ($entityColumns as $entityColumn) { $contactInfoColumns[$entityColumn] = $contactInfoType; } } } } return $contactInfoColumns; }
/** * Goes across bundles and collects configurations * * @return array */ public function collectConfigs() { if (!$this->collectedConfig) { $config = $this->container->getParameter('oro_require_js'); $bundles = $this->container->getParameter('kernel.bundles'); foreach ($bundles as $bundle) { $reflection = new \ReflectionClass($bundle); if (is_file($file = dirname($reflection->getFilename()) . '/Resources/config/requirejs.yml')) { $requirejs = Yaml::parse(realpath($file)); $config = ArrayUtil::arrayMergeRecursiveDistinct($config, $requirejs); } } $this->collectedConfig = $config; } return $this->collectedConfig; }
/** * @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; }
/** * @param $type * * @return bool */ protected function typedNodesExists($type) { return ArrayUtil::some(function ($node) use($type) { $exists = false; if ($node instanceof GroupNode) { $exists = $node->getType() === $type; } else { switch ($type) { case GroupNode::TYPE_COMPUTED: $exists = $node->isComputed(); break; case GroupNode::TYPE_UNCOMPUTED: $exists = !$node->isComputed(); } } return $exists; }, $this->nodes); }
/** * 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); }
/** * @dataProvider mergeDataProvider * * @param array $expected * @param array $first * @param array $second */ public function testArrayMergeRecursiveDistinct(array $expected, array $first, array $second) { $this->assertEquals($expected, ArrayUtil::arrayMergeRecursiveDistinct($first, $second)); }