/**
* 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));
}
