public function testBuild()
{
$type = 'history';
$userId = 1;
$user = $this->getMockBuilder('stdClass')->setMethods(['getId'])->getMock();
$user->expects($this->once())->method('getId')->will($this->returnValue($userId));
$token = $this->getMock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\TokenInterface');
$token->expects($this->once())->method('getUser')->will($this->returnValue($user));
$this->tokenStorage->expects($this->once())->method('getToken')->will($this->returnValue($token));
$item = $this->getMock('Oro\\Bundle\\NavigationBundle\\Entity\\NavigationItemInterface');
$this->factory->expects($this->once())->method('createItem')->with($type, [])->will($this->returnValue($item));
$repository = $this->getMockBuilder('Oro\\Bundle\\NavigationBundle\\Entity\\Repository\\HistoryItemRepository')->disableOriginalConstructor()->getMock();
$items = [['id' => 1, 'title' => 'test1', 'url' => '/'], ['id' => 2, 'title' => 'test2', 'url' => '/home']];
$repository->expects($this->once())->method('getNavigationItems')->with($userId, $type)->will($this->returnValue($items));
$this->em->expects($this->once())->method('getRepository')->with(get_class($item))->will($this->returnValue($repository));
$menu = $this->getMockBuilder('Knp\\Menu\\MenuItem')->disableOriginalConstructor()->getMock();
$childMock = $this->getMock('Knp\\Menu\\ItemInterface');
$childMock2 = clone $childMock;
$children = [$childMock, $childMock2];
$matcher = $this->getMock('\\Knp\\Menu\\Matcher\\Matcher');
$matcher->expects($this->once())->method('isCurrent')->will($this->returnValue(true));
$this->builder->setMatcher($matcher);
$menu->expects($this->exactly(2))->method('addChild');
$menu->expects($this->once())->method('setExtra')->with('type', $type);
$menu->expects($this->once())->method('getChildren')->will($this->returnValue($children));
$menu->expects($this->once())->method('removeChild');
$n = rand(1, 10);
$configMock = $this->getMockBuilder('Oro\\Bundle\\ConfigBundle\\Config\\UserConfigManager')->disableOriginalConstructor()->getMock();
$configMock->expects($this->once())->method('get')->with($this->equalTo('oro_navigation.maxItems'))->will($this->returnValue($n));
$this->manipulator->expects($this->once())->method('slice')->with($menu, 0, $n);
$this->builder->setOptions($configMock);
$this->builder->build($menu, [], $type);
}
public function buildForm(FormBuilderInterface $builder, array $options)
{
/** @var \Claroline\CoreBundle\Entity\User $user */
$user = $this->tokenStorage->getToken()->getUser();
$locale = null === $user->getLocale() ? $this->platformConfigHandler->getParameter('locale_language') : $user->getLocale();
$builder->add('badge', 'zenstruck_ajax_entity', array('attr' => array('class' => 'fullwidth'), 'theme_options' => array('control_width' => 'col-md-3'), 'placeholder' => $this->translator->trans('badge_form_badge_selection', array(), 'icap_badge'), 'class' => 'IcapBadgeBundle:Badge', 'use_controller' => true, 'repo_method' => sprintf('findByNameForAjax'), 'extra_data' => array('userId' => $user->getId(), 'locale' => $locale)));
}
/**
* Sets up the fixture, for example, opens a network connection.
* This method is called before a test is executed.
*/
protected function setUp()
{
$this->em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
/* @var $conn Connection */
$conn = $this->getMockBuilder('Doctrine\\DBAL\\Connection')->disableOriginalConstructor()->getMock();
$conn->expects($this->any())->method('getDatabase')->will($this->returnValue('myDatabase'));
/* @var $platform AbstractPlatform */
$platform = $this->getMockForAbstractClass('Doctrine\\DBAL\\Platforms\\AbstractPlatform');
$conn->expects($this->any())->method('getDatabasePlatform')->will($this->returnValue($platform));
/* @var $stmt Statement */
$stmt = $this->getMockForAbstractClass('Kunstmaan\\AdminBundle\\Tests\\Mocks\\StatementMock');
$conn->expects($this->any())->method('executeQuery')->will($this->returnValue($stmt));
$this->em->expects($this->any())->method('getConnection')->will($this->returnValue($conn));
/* @var $conf Configuration */
$conf = $this->getMockBuilder('Doctrine\\ORM\\Configuration')->disableOriginalConstructor()->getMock();
/* @var $strat QuoteStrategy */
$strat = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\QuoteStrategy')->disableOriginalConstructor()->getMock();
$strat->expects($this->any())->method('getTableName')->will($this->returnValue('rootTable'));
$conf->expects($this->any())->method('getQuoteStrategy')->will($this->returnValue($strat));
$conf->expects($this->any())->method('getDefaultQueryHints')->willReturn(array());
$conf->expects($this->any())->method('isSecondLevelCacheEnabled')->willReturn(false);
$this->em->expects($this->any())->method('getConfiguration')->will($this->returnValue($conf));
/* @var $meta ClassMetadata */
$meta = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\ClassMetadata')->disableOriginalConstructor()->getMock();
$this->em->expects($this->any())->method('getClassMetadata')->will($this->returnValue($meta));
$this->tokenStorage = $this->getMockBuilder('Symfony\\Component\\Security\\Core\\Authentication\\Token\\Storage\\TokenStorageInterface')->getMock();
$this->token = $this->getMockBuilder('Symfony\\Component\\Security\\Core\\Authentication\\Token\\TokenInterface')->getMock();
$this->tokenStorage->expects($this->any())->method('getToken')->will($this->returnValue($this->token));
$this->rh = $this->getMockBuilder('Symfony\\Component\\Security\\Core\\Role\\RoleHierarchyInterface')->getMock();
$this->object = new AclHelper($this->em, $this->tokenStorage, $this->rh);
}
function it_returns_locale_of_currently_logged_admin_user(TokenStorageInterface $tokenStorage, TokenInterface $token, AdminUserInterface $admin)
{
$admin->getLocaleCode()->willReturn('en_US');
$token->getUser()->willreturn($admin);
$tokenStorage->getToken()->willReturn($token);
$this->getLocaleCode()->shouldReturn('en_US');
}
/**
* Get the attribute collection.
*
* TODO This action is only accessible via a GET or POST query, because of too long query URI. To respect standards,
* a refactor must be done.
*
* @param Request $request
*
* @return JsonResponse
*/
public function indexAction(Request $request)
{
$options = [];
$context = ['include_group' => true];
if ($request->request->has('identifiers')) {
$options['identifiers'] = explode(',', $request->request->get('identifiers'));
$context['include_group'] = false;
}
if ($request->request->has('types')) {
$options['types'] = explode(',', $request->request->get('types'));
}
if (empty($options)) {
$options = $request->request->get('options', ['limit' => SearchableRepositoryInterface::FETCH_LIMIT, 'locale' => null]);
}
$token = $this->tokenStorage->getToken();
$options['user_groups_ids'] = $token->getUser()->getGroupsIds();
if (null !== $this->attributeSearchRepository) {
$attributes = $this->attributeSearchRepository->findBySearch($request->request->get('search'), $options);
} else {
if (isset($options['identifiers'])) {
$options['code'] = $options['identifiers'];
}
$attributes = $this->attributeRepository->findBy($options);
}
$normalizedAttributes = $this->normalizer->normalize($attributes, 'internal_api', $context);
return new JsonResponse($normalizedAttributes);
}
/**
* Set the username from injected security context
* @param TokenStorageInterface $securityTokenStorage
* @param AuditLogManager $auditLogManager
*/
public function __construct(TokenStorageInterface $securityTokenStorage, AuditLogManager $auditLogManager)
{
if (null !== $securityTokenStorage && null !== $securityTokenStorage->getToken()) {
$this->user = $securityTokenStorage->getToken()->getUser();
}
$this->manager = $auditLogManager;
}
public function __construct(ItemFactory $navigationItemFactory, TokenStorageInterface $tokenStorage, EntityManager $entityManager, TitleServiceInterface $titleService)
{
$this->navItemFactory = $navigationItemFactory;
$this->user = !$tokenStorage->getToken() || is_string($tokenStorage->getToken()->getUser()) ? null : $tokenStorage->getToken()->getUser();
$this->em = $entityManager;
$this->titleService = $titleService;
}
private function getUserFromTokenStorage()
{
if (($token = $this->tokenStorage->getToken()) !== null) {
return $token->getUser();
}
throw new \RuntimeException('I don\'t have a token');
}
/**
* @return \Symfony\Component\Security\Core\User\UserInterface
*/
private function getUser()
{
if (is_null($this->user)) {
$this->user = $this->tokenStorage->getToken()->getUser();
}
return $this->user;
}
/**
* {@inheritdoc}
*/
public function handle(GetResponseEvent $event)
{
$request = $event->getRequest();
if (null !== ($authorization = $request->headers->get($this->authenticationHeaderName))) {
$headerParts = array_map('trim', explode(' ', $authorization, 2));
if (2 === count($headerParts)) {
$credentialParts = explode(':', $headerParts[1]);
if (2 === count($credentialParts)) {
$token = new HmacUserToken();
$token->setServiceLabel($headerParts[0]);
$token->setUser($credentialParts[0]);
$token->setSignature($credentialParts[1]);
$token->setRequest($request);
try {
$authenticatedToken = $this->authenticationManager->authenticate($token);
// Call setToken() on an instance of SecurityContextInterface or TokenStorageInterface (>=2.6)
$this->tokenStorage->setToken($authenticatedToken);
// Success
return;
} catch (AuthenticationException $exception) {
}
}
}
}
$event->setResponse(new Response(null, 401));
}
/**
* Merge in dashboard list into runtime configuration.
*
* {@inheritdoc}
*/
public function merge(array $currentConfig)
{
/** @var User $user */
$user = $this->tokenStorage->getToken()->getUser();
$defaultDashboardNames = [];
foreach ($this->dashboardMgr->getDefaultDashboards($user) as $dashboard) {
$defaultDashboardNames[] = $dashboard->getName();
}
$isDefaultFound = false;
$result = array();
foreach ($this->dashboardMgr->getUserDashboards($user) as $dashboard) {
if (!$dashboard->isAllowed($this->container)) {
continue;
}
$isDefault = in_array($dashboard->getName(), $defaultDashboardNames);
if ($isDefault) {
$isDefaultFound = true;
}
$result[] = array_merge($this->serializeDashboard($dashboard), array('default' => $isDefault));
}
if (!$isDefaultFound) {
// if there's no default dashboard available for a given user then we will display a dashboard
// where user will be able to pick one he/she needs
$dashboard = new SimpleDashboard('default', 'List of user dashboards', 'Modera.backend.dashboard.runtime.DashboardListDashboardActivity');
$result[] = array_merge($this->serializeDashboard($dashboard), array('default' => true));
}
return array_merge($currentConfig, array('modera_backend_dashboard' => array('dashboards' => $result)));
}
/**
* Constructor.
*
* @param TokenStorageInterface $aTokenStorage The token storage
*/
public function __construct(TokenStorageInterface $aTokenStorage)
{
$token = $aTokenStorage->getToken();
if ($token instanceof TokenInterface) {
$this->currentUser = $token->getUser() instanceof UserInterface ? $token->getUser() : null;
}
}
public function __construct(TokenStorageInterface $token, ComunidadProvider $comunidadProvider, ControllerResolverInterface $resolver, LoggerInterface $logger)
{
$this->token = $token->getToken();
$this->comunidadProvider = $comunidadProvider;
$this->resolver = $resolver;
$this->logger = $logger;
}
/**
* @param GetResponseEvent $event
*/
public function handle(GetResponseEvent $event)
{
$request = $event->getRequest();
if (empty($request->headers->get("Authorization"))) {
return;
}
$authHeader = $request->headers->get("Authorization");
if (strpos($authHeader, " ") === false) {
return;
}
list($tokenType, $token) = explode(" ", $authHeader, 2);
if (strtolower($tokenType) !== "bearer") {
return;
}
// Verify that there is an access_token present
/*
if(empty($request->get("access_token"))) {
return;
}
$token = $request->get("access_token");*/
$unauthenticatedToken = new OAuthToken();
$unauthenticatedToken->setToken($token);
try {
$authenticatedToken = $this->authenticationManager->authenticate($unauthenticatedToken);
$this->tokenStorage->setToken($authenticatedToken);
return;
} catch (AuthenticationException $e) {
if ($this->logger !== null) {
$this->logger->notice("Access token authentication failed");
}
}
$response = new Response();
$response->setStatusCode(Response::HTTP_FORBIDDEN);
$event->setResponse($response);
}
public function handle(GetResponseEvent $event)
{
$request = $event->getRequest();
//find out if the current request contains any information by which the user might be authenticated
if (!$request->headers->has('X-WSSE')) {
return;
}
$ae_message = null;
$this->wsseHeader = $request->headers->get('X-WSSE');
$wsseHeaderInfo = $this->parseHeader();
if ($wsseHeaderInfo !== false) {
$token = new Token($wsseHeaderInfo['Username'], $wsseHeaderInfo['PasswordDigest'], $this->providerKey);
$token->setAttribute('nonce', $wsseHeaderInfo['Nonce']);
$token->setAttribute('created', $wsseHeaderInfo['Created']);
try {
$returnValue = $this->authenticationManager->authenticate($token);
if ($returnValue instanceof TokenInterface) {
return $this->tokenStorage->setToken($returnValue);
} else {
if ($returnValue instanceof Response) {
return $event->setResponse($returnValue);
}
}
} catch (AuthenticationException $ae) {
$event->setResponse($this->authenticationEntryPoint->start($request, $ae));
}
}
}
/**
* MenuHelper constructor.
*
* @param CorePermissions $security
* @param TokenStorageInterface $tokenStorage
* @param RequestStack $requestStack
* @param array $mauticParameters
*/
public function __construct(CorePermissions $security, TokenStorageInterface $tokenStorage, RequestStack $requestStack, array $mauticParameters)
{
$this->security = $security;
$this->user = $tokenStorage->getToken()->getUser();
$this->mauticParameters = $mauticParameters;
$this->request = $requestStack->getCurrentRequest();
}
public function buildForm(FormBuilderInterface $builder, array $options)
{
$token = $this->tokenStorage->getToken();
if ($token === null) {
throw new \LogicException('Unable to get token from security storage for portfolio widget form!');
}
$user = $token->getUser();
if (!$user) {
throw new \LogicException('Unable to get connected user for portfolio widget form!');
}
$builder->add('portfolio_id', 'entity', ['class' => 'IcapPortfolioBundle:Portfolio', 'query_builder' => function (EntityRepository $entityRepository) use($user) {
return $entityRepository->createQueryBuilder('p')->where('p.user = :user')->setParameter('user', $user);
}, 'property_path' => 'portfolio'])->add('widget_id', 'entity', ['class' => 'IcapPortfolioBundle:Widget\\AbstractWidget', 'query_builder' => function (EntityRepository $entityRepository) use($user) {
return $entityRepository->createQueryBuilder('w')->where('w.user = :user')->setParameter('user', $user);
}, 'property_path' => 'widget'])->add('col', 'integer')->add('row', 'integer')->add('sizeX', 'integer')->add('sizeY', 'integer');
$builder->addEventListener(FormEvents::PRE_SET_DATA, function (FormEvent $event) use($user) {
$form = $event->getForm();
$choices = [];
$choiceTypes = $this->widgetTypeManager->getWidgetsTypes();
foreach ($choiceTypes as $choiceType) {
$choices[$choiceType['name']] = $choiceType['name'];
}
$form->add('widget_type', 'choice', ['choices' => $choices]);
});
}
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$object = new \ReflectionObject($controller[0]);
$method = $object->getMethod($controller[1]);
$classConfigurations = $this->reader->getClassAnnotations($object);
$methodConfigurations = $this->reader->getMethodAnnotations($method);
foreach (array_merge($classConfigurations, $methodConfigurations) as $configuration) {
if ($configuration instanceof OAuth2) {
$token = $this->token_storage->getToken();
// If no access token is found by the firewall, then returns an authentication error
if (!$token instanceof OAuth2Token) {
$this->createAuthenticationException($event, 'OAuth2 authentication required');
return;
}
foreach ($this->getCheckers() as $checker) {
$result = $checker->check($token, $configuration);
if (null !== $result) {
$this->createAccessDeniedException($event, $result);
return;
}
}
}
}
}
/**
* @return Item
*/
private function createRootItem()
{
$rootItem = new Item('account');
$rootItem->setLabel($this->translator->trans('admin.welcome', array('%username%' => $this->tokenStorage->getToken()->getUsername()), 'FSiAdminSecurity'));
$rootItem->setOptions(array('attr' => array('id' => 'account')));
return $rootItem;
}
/**
* AbstractJournalItemMailer constructor.
* @param OjsMailer $ojsMailer
* @param RegistryInterface $registry
* @param TokenStorageInterface $tokenStorage
* @param RouterInterface $router
*/
public function __construct(OjsMailer $ojsMailer, RegistryInterface $registry, TokenStorageInterface $tokenStorage, RouterInterface $router)
{
$this->ojsMailer = $ojsMailer;
$this->em = $registry->getManager();
$this->user = $tokenStorage->getToken() ? $tokenStorage->getToken()->getUser() : null;
$this->router = $router;
}
public function showUser(ShowUserEvent $event)
{
if ($this->tokenStorage->getToken()->isAuthenticated()) {
$user = $this->tokenStorage->getToken()->getUser();
$event->setUser($user);
}
}
/**
* {@inheritdoc}
*/
public function generate(Request $request)
{
$token = $this->tokenStorage->getToken();
$user = null === $token ? 'anon.' : $token->getUser();
$version = sprintf('u:%s', is_string($user) ? $user : $user->getId());
return $version;
}
private function generateErrorForException(\Exception $exception)
{
if ($exception instanceof CommandInvalidException) {
$formError = $exception->getForm()->getErrors(true)->current();
$path = $formError->getOrigin()->getPropertyPath();
if ($path !== null) {
// We got PropertyPathInterface or maybe even a string (undocumented).
$path = (string) $path;
}
return new E\Api\BadRequest($formError->getMessage(), $path);
} elseif ($exception instanceof ConstraintViolationException) {
return $exception->getError();
} elseif ($exception instanceof UsernameNotFoundException) {
return new E\Security\BadCredentials();
} elseif ($exception instanceof AccessDeniedException) {
$token = $this->tokenStorage->getToken();
if ($token && $this->tokenStorage->getToken()->getRoles()) {
return new E\Security\NotAuthorized();
} else {
return new E\Security\NotAuthenticated();
}
} elseif ($exception instanceof ProtocolException) {
return $this->getErrorForOxygenProtocolException($exception);
} else {
return new E\Api\UnexpectedError();
}
}
public function handle(GetResponseEvent $event)
{
// getting request
$request = $event->getRequest();
// getting attributes
$apiClientToken = $request->attributes->get('apiClientToken');
$apiUserToken = $request->attributes->get('apiUserToken');
$apiServerAction = $request->attributes->get('apiAction');
/* @var $apiServerAction ApiServerAction */
// cleaning credentials and interface name
$request->attributes->remove('apiClientToken');
$request->attributes->remove('apiUserToken');
// creating token
$token = new Token($apiServerAction->getApiServerInterface());
$token->setCredentials([$apiClientToken, $apiUserToken]);
try {
// authenticating
$authenticatedToken = $this->authenticationManager->authenticate($token);
$this->tokenStorage->setToken($authenticatedToken);
// getting authenticated user
$user = $authenticatedToken->getUser();
/* @var $user User */
// setting request attributes
$request->attributes->set('apiConnection', $user->getApiConnection());
$request->attributes->set('apiClient', $user->getApiClient());
$request->attributes->set('apiUser', $user->getApiUser());
} catch (\Exception $e) {
$event->stopPropagation();
throw new AccessDeniedHttpException(null, $e);
}
}
/**
* If user is logged-in in legacy_mode (e.g. legacy admin interface),
* will inject currently logged-in user in the repository.
*
* @param GetResponseEvent $event
*/
public function onKernelRequest(GetResponseEvent $event)
{
/** @var \eZ\Publish\Core\MVC\ConfigResolverInterface $configResolver */
$request = $event->getRequest();
$session = $request->getSession();
if ($event->getRequestType() !== HttpKernelInterface::MASTER_REQUEST || !$this->configResolver->getParameter('legacy_mode') || !($session->isStarted() && $session->has('eZUserLoggedInID'))) {
return;
}
try {
$apiUser = $this->repository->getUserService()->loadUser($session->get('eZUserLoggedInID'));
$this->repository->setCurrentUser($apiUser);
$token = $this->tokenStorage->getToken();
if ($token instanceof TokenInterface) {
$token->setUser(new User($apiUser));
// Don't embed if we already have a LegacyToken, to avoid nested session storage.
if (!$token instanceof LegacyToken) {
$this->tokenStorage->setToken(new LegacyToken($token));
}
}
} catch (NotFoundException $e) {
// Invalid user ID, the user may have been removed => invalidate the token and the session.
$this->tokenStorage->setToken(null);
$session->invalidate();
}
}
/**
* @param EntityManager $em
* @param RESTResponse $response
* @param ValidatorInterface $validator
* @param TokenStorageInterface $tokenStorage
*/
public function __construct($em, $response, $validator, $tokenStorage)
{
$this->em = $em;
$this->response = $response;
$this->validator = $validator;
$this->user = $tokenStorage->getToken()->getUser();
}
/**
* @param GetResponseEvent $event
*/
public function handle(GetResponseEvent $event)
{
if (null !== $this->tokenStorage->getToken()) {
return;
}
$request = $event->getRequest();
$token = new PluginToken($this->providerKey, $request->get('integration', null));
try {
$authToken = $this->authenticationManager->authenticate($token);
if ($authToken instanceof PluginToken) {
$response = $authToken->getResponse();
if ($authToken->isAuthenticated()) {
$this->tokenStorage->setToken($authToken);
if ('api' != $this->providerKey) {
$response = $this->onSuccess($request, $authToken, $response);
}
} elseif (empty($response)) {
throw new AuthenticationException('mautic.user.auth.error.invalidlogin');
}
}
} catch (AuthenticationException $exception) {
if ('api' != $this->providerKey) {
$response = $this->onFailure($request, $exception);
}
}
if ($response) {
$event->setResponse($response);
}
}
public function __construct(EntityManager $oEntityManager, TokenStorageInterface $oUser, Ebay $oEbay)
{
$this->oEm = $oEntityManager;
$this->oEbayProfiles = $this->oEm->getRepository('EparServiceBundle:EbayProfiles');
$this->oUser = $oUser->getToken()->getUser();
$this->oEbay = $oEbay;
}
/**
* Returns the context for the given activity class and id
*
* @param string $class The FQCN of the activity entity
* @param $id
*
* @return array
*/
public function getActivityContext($class, $id)
{
$currentUser = $this->securityTokenStorage->getToken()->getUser();
$userClass = ClassUtils::getClass($currentUser);
$entity = $this->doctrineHelper->getEntity($class, $id);
$result = [];
if (!$entity || !$entity instanceof ActivityInterface) {
return $result;
}
$targets = $entity->getActivityTargetEntities();
$entityProvider = $this->configManager->getProvider('entity');
foreach ($targets as $target) {
$targetClass = ClassUtils::getClass($target);
$targetId = $target->getId();
if ($userClass === $targetClass && $currentUser->getId() === $targetId) {
continue;
}
$item = [];
$config = $entityProvider->getConfig($targetClass);
$safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($targetClass);
$item = $this->prepareItemTitle($item, $targetClass, $target, $targetId);
$item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class);
$item['entityId'] = $id;
$item['targetId'] = $targetId;
$item['targetClassName'] = $safeClassName;
$item['icon'] = $config->get('icon');
$item['link'] = $this->getContextLink($targetClass, $targetId);
$item = $this->dispatchContextTitle($item, $targetClass);
$result[] = $item;
}
return $result;
}
/**
* {@inheritdoc}
*/
public function getParameters()
{
if (null === $this->tokenStorage->getToken()) {
return ['settingKey' => self::SETTING_KEY];
}
$user = $this->tokenStorage->getToken()->getUser();
if (!$user instanceof UserInterface) {
return ['settingKey' => self::SETTING_KEY];
}
$result = [];
$exists = false;
foreach ($user->getRoleObjects() as $role) {
if (null === ($setting = $role->getSetting(self::SETTING_KEY))) {
continue;
}
$result = array_merge_recursive($result, $setting->getValue());
$exists = true;
}
if (!$exists) {
return ['settingKey' => self::SETTING_KEY];
}
// array_merge_recursive accepts non-unique values they have to be removed
foreach (array_keys($result) as $section) {
$result[$section] = array_values(array_unique($result[$section]));
}
return ['settingKey' => self::SETTING_KEY, 'userToolbar' => $result];
}
