public function testFailureSendPassword()
{
$ms = new MailService($this->em, $this->mailer, 'en', 'no-reply@no-reply');
$user = new User();
$user->setEmail('*****@*****.**');
$this->assertTrue(is_array($ms->sendPassword($user, 'password')));
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
/* @var EntityManager $em */
$em = $this->getContainer()->get('doctrine.orm.entity_manager');
$username = $input->getOption('username');
$email = $input->getOption('email');
$password = $input->getOption('password');
if (false === $input->getOption('no-interactions')) {
/* @var DialogHelper $dialog */
$dialog = $this->getHelper('dialog');
$output->writeln('<info>This command will let you to create a test user that you can user to authenticated to administration interface</info>');
$output->write(PHP_EOL);
$username = $dialog->ask($output, '<question>Username:</question> ');
$email = $dialog->ask($output, '<question>Email:</question> ');
do {
$password = $dialog->askHiddenResponse($output, '<question>Password:</question> ');
$passwordConfirm = $dialog->askHiddenResponse($output, '<question>Password again:</question> ');
if ($password != $passwordConfirm) {
$output->writeln('<error>Entered passwords do not match, please try again</error>');
}
} while ($password != $passwordConfirm);
}
/* @var UserPasswordEncoderInterface $encoder */
$encoder = $this->getContainer()->get('security.password_encoder');
$user = new User();
$user->setEmail($email);
$user->setUsername($username);
$user->setPassword($encoder->encodePassword($user, $password));
$em->persist($user);
$em->flush();
$output->writeln('');
$output->writeln(sprintf('<info>Great success! User "%s" has been successfully created!</info>', $user->getUsername()));
}
/**
* @param User $user
*
* @return string
*/
private function getLocale(User $user)
{
$settings = $this->em->getRepository(UserSettings::clazz())->findOneBy(array('user' => $user->getId()));
if ($settings && $settings->getLanguage() && $settings->getLanguage()->getEnabled()) {
return $settings->getLanguage()->getLocale();
}
return $this->defaultLocale;
}
public function testMapData_WillBeNotTouched()
{
$meta = array('WillExistsAfterMapping' => true);
$params = array('lastName' => 'Last Name');
$user = new User();
$user->setMeta($meta);
$this->mapper->mapData($params, $user);
$this->assertEquals('Last Name', $user->getLastName());
$this->assertEquals($meta, $user->getMeta());
}
public function testGetRoles()
{
$user = new User();
$this->assertEquals(['ROLE_USER'], $user->getRoles());
// ---
$rootUserHandler = \Phake::mock('Modera\\SecurityBundle\\RootUserHandling\\RootUserHandlerInterface');
\Phake::when($rootUserHandler)->isRootUser($user)->thenReturn(false);
\Phake::when($rootUserHandler)->getRoles()->thenReturn(['ROLE_FOO', 'ROLE_BAR']);
$user->init($rootUserHandler);
$this->assertEquals(['ROLE_USER'], $user->getRoles());
// ---
\Phake::when($rootUserHandler)->isRootUser($user)->thenReturn(true);
$this->assertEquals(['ROLE_FOO', 'ROLE_BAR'], $user->getRoles());
}
/**
* @param string $queryType
* @param string $query
*
* @return array[]
*/
public function suggest($queryType, $query)
{
if ('user' == $queryType) {
$dql = $this->em->createQuery(sprintf('SELECT u FROM %s u WHERE u.firstName LIKE ?0 OR u.lastName LIKE ?0 OR u.username LIKE ?0 OR u.email LIKE ?0', User::clazz()));
$dql->setParameter(0, '%' . $query . '%');
$rawResult = [];
foreach ($dql->getResult() as $user) {
/* @var User $user */
$value = $this->stringifyUser($user);
$rawResult[] = array('id' => $user->getId(), 'value' => $value);
}
return $rawResult;
} elseif ('exact-user' == $queryType) {
// find by ID
$user = $this->em->find(User::clazz(), $query);
if (!$user) {
throw new \DomainException(T::trans('Unable to find a user "%username%"', array('%username%' => $query)));
}
return [array('id' => $user->getId(), 'value' => $this->stringifyUser($user))];
} elseif ('eventType' == $queryType) {
$activities = $this->activityManager->query(array('filter' => [array('property' => 'type', 'value' => 'like:%' . $query . '%')]));
$rawResult = [];
foreach ($activities['items'] as $activity) {
/* @var ActivityInterface $activity */
$rawResult[] = $activity->getType();
}
$rawResult = array_values(array_unique($rawResult));
$result = [];
foreach ($rawResult as $item) {
$result[] = array('id' => $item, 'value' => $item);
}
return $result;
}
}
public function testPostLoadWithEntity()
{
$user = \Phake::mock(User::clazz());
$event = $this->createEvent($user);
$listener = new RootUserHandlerInjectionListener($this->container);
$listener->postLoad($event);
\Phake::verify($user)->init($this->rootUserHandler);
}
public function testGetByRole()
{
$user1 = new User();
$user2 = new User();
$user3 = new User();
$user1->setUsername('user1');
$user1->setPassword('pwd1');
$user1->setEmail('*****@*****.**');
$user2->setUsername('user2');
$user2->setPassword('pwd2');
$user2->setEmail('*****@*****.**');
$user3->setUsername('user3');
$user3->setPassword('pwd3');
$user3->setEmail('*****@*****.**');
$permission1 = new Permission();
$permission2 = new Permission();
$permission1->setRoleName('ROLE_USER');
$permission1->addUser($user1);
$permission2->setRoleName('ROLE_ADMIN');
$permission2->addUser($user2);
$group1 = new Group();
$group2 = new Group();
$group1->setName('User');
$group1->addPermission($permission1);
$group1->addUser($user3);
$group2->setName('Admin');
$group2->addPermission($permission2);
$group2->addUser($user3);
self::$em->persist($user1);
self::$em->persist($user2);
self::$em->persist($user3);
self::$em->persist($permission1);
self::$em->persist($permission2);
self::$em->persist($group1);
self::$em->persist($group2);
self::$em->flush();
$rootUserHandler = \Phake::mock('Modera\\SecurityBundle\\RootUserHandling\\RootUserHandlerInterface');
$service = new UserService(self::$em, $rootUserHandler);
$this->assertEquals(array($user1, $user3), $service->getUsersByRole('ROLE_USER'));
$this->assertEquals(array($user2, $user3), $service->getUsersByRole('ROLE_ADMIN'));
$this->assertEquals(array($user1->getId(), $user3->getId()), $service->getIdsByRole('ROLE_USER'));
$this->assertEquals(array($user2->getId(), $user3->getId()), $service->getIdsByRole('ROLE_ADMIN'));
}
public function testRootUser()
{
$em = \Phake::mock('Doctrine\\ORM\\EntityManager');
$rootUserHandler = \Phake::mock('Modera\\SecurityBundle\\RootUserHandling\\RootUserHandlerInterface');
$service = new UserService($em, $rootUserHandler);
$user = \Phake::mock(User::clazz());
\Phake::when($rootUserHandler)->getUser()->thenReturn($user);
\Phake::when($rootUserHandler)->isRootUser($user)->thenReturn(true);
$this->assertEquals($user, $service->getRootUser());
$this->assertTrue($service->isRootUser($user));
}
public function testSecurityRolesMerger()
{
$roles = array(new Role('ROLE_USER'), new Role('ROLE_ADMIN'));
$user = \Phake::mock(User::clazz());
\Phake::when($user)->getId()->thenReturn(777);
\Phake::when($user)->getFullName()->thenReturn('John Doe');
\Phake::when($user)->getEmail()->thenReturn('*****@*****.**');
\Phake::when($user)->getUsername()->thenReturn('john.doe');
$token = \Phake::mock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\TokenInterface');
\Phake::when($token)->getUser()->thenReturn($user);
\Phake::when($token)->getRoles()->thenReturn($roles);
$serviceDefinitions = array('fooService', 'barService');
$clientDiDefinitionsProvider = $this->createMock(ContributorInterface::CLAZZ);
$clientDiDefinitionsProvider->expects($this->atLeastOnce())->method('getItems')->will($this->returnValue($serviceDefinitions));
$tokenStorage = \Phake::mock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\Storage\\TokenStorageInterface');
\Phake::when($tokenStorage)->getToken()->thenReturn($token);
$provider = new ConfigMergersProvider($tokenStorage, $clientDiDefinitionsProvider);
$mergers = $provider->getItems();
$this->assertEquals(2, count($mergers));
/* @var ConfigMergerInterface $securityRolesMerger */
$securityRolesMerger = $mergers[0];
/* @var ConfigMergerInterface $clientDiDefinitionsProviderMerger */
$clientDiDefinitionsProviderMerger = $mergers[1];
$this->assertInstanceOf('Modera\\MjrIntegrationBundle\\Config\\ConfigMergerInterface', $securityRolesMerger);
$this->assertInstanceOf('Modera\\MjrIntegrationBundle\\Config\\ConfigMergerInterface', $clientDiDefinitionsProviderMerger);
$existingConfig = array('something' => 'blah');
$mergedConfig = $securityRolesMerger->merge($existingConfig);
$this->assertTrue(is_array($mergedConfig));
$this->assertArrayHasKey('something', $mergedConfig);
$this->assertEquals('blah', $mergedConfig['something']);
$this->assertArrayHasKey('roles', $mergedConfig);
$this->assertTrue(is_array($mergedConfig['roles']));
$this->assertEquals(2, count($mergedConfig['roles']));
$this->assertTrue(in_array('ROLE_USER', $mergedConfig['roles']));
$this->assertTrue(in_array('ROLE_ADMIN', $mergedConfig['roles']));
$this->assertArrayHasKey('userProfile', $mergedConfig);
$this->assertTrue(is_array($mergedConfig['userProfile']));
$this->assertArrayHasKey('id', $mergedConfig['userProfile']);
$this->assertArrayHasKey('name', $mergedConfig['userProfile']);
$this->assertArrayHasKey('email', $mergedConfig['userProfile']);
$this->assertArrayHasKey('username', $mergedConfig['userProfile']);
$this->assertEquals(777, $mergedConfig['userProfile']['id']);
$this->assertEquals('John Doe', $mergedConfig['userProfile']['name']);
$this->assertEquals('*****@*****.**', $mergedConfig['userProfile']['email']);
$this->assertEquals('john.doe', $mergedConfig['userProfile']['username']);
$mergedConfig = $clientDiDefinitionsProviderMerger->merge($existingConfig);
$this->assertArrayHasKey('serviceDefinitions', $mergedConfig);
$this->assertTrue(is_array($mergedConfig['serviceDefinitions']));
$this->assertEquals(2, count($mergedConfig['serviceDefinitions']));
$this->assertTrue(in_array('fooService', $mergedConfig['serviceDefinitions']));
$this->assertTrue(in_array('barService', $mergedConfig['serviceDefinitions']));
}
private function createUser()
{
$u = new User();
$u->setFirstName('Joe');
$u->setLastName('Doe');
$u->setUsername('djatel');
$u->setEmail('*****@*****.**');
$u->setPassword(1234);
self::$em->persist($u);
self::$em->flush();
return $u;
}
/**
* @param ActivityInterface $activity
*
* @return array
*/
public function resolve(ActivityInterface $activity)
{
$isId = preg_match('/^[0-9]+$/', $activity->getAuthor());
if ($isId) {
/* @var User $user */
$user = $this->om->find(User::clazz(), $activity->getAuthor());
if ($user) {
return array('id' => $user->getId(), 'isUser' => true, 'fullName' => $user->getFullName(), 'username' => $user->getUsername());
} else {
return array('isUser' => false, 'identity' => $activity->getAuthor());
}
} else {
return array('isUser' => false, 'identity' => $activity->getAuthor() ? $activity->getAuthor() : T::trans('Unknown'));
}
}
public function testIsRootUser()
{
$container = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
$bundleConfig = array('root_user' => array('query' => array('dat', 'is', 'query')));
$em = \Phake::mock('Doctrine\\ORM\\EntityManager');
\Phake::when($container)->getParameter(ModeraSecurityExtension::CONFIG_KEY)->thenReturn($bundleConfig);
\Phake::when($container)->get('doctrine.orm.entity_manager')->thenReturn($em);
$handler = new SemanticConfigRootUserHandler($container);
$anonymousUser = \Phake::mock(User::clazz());
$dbUser = \Phake::mock(User::clazz());
\Phake::when($dbUser)->isEqualTo($anonymousUser)->thenReturn('dat is true');
$userRepository = \Phake::mock('Doctrine\\Common\\Persistence\\ObjectRepository');
\Phake::when($userRepository)->findOneBy($bundleConfig['root_user']['query'])->thenReturn($dbUser);
\Phake::when($em)->getRepository(User::clazz())->thenReturn($userRepository);
$this->assertEquals('dat is true', $handler->isRootUser($anonymousUser));
}
public function testUserToArray()
{
$user = \Phake::mock(User::clazz());
\Phake::when($user)->getId()->thenReturn(777);
\Phake::when($user)->getFullName()->thenReturn('John Doe');
\Phake::when($user)->getEmail()->thenReturn('*****@*****.**');
\Phake::when($user)->getUsername()->thenReturn('john.doe');
$result = Authenticator::userToArray($user);
$this->assertTrue(is_array($result));
$this->assertArrayHasKey('id', $result);
$this->assertArrayHasKey('name', $result);
$this->assertArrayHasKey('email', $result);
$this->assertArrayHasKey('username', $result);
$this->assertEquals(777, $result['id']);
$this->assertEquals('John Doe', $result['name']);
$this->assertEquals('*****@*****.**', $result['email']);
$this->assertEquals('john.doe', $result['username']);
}
public function testGetItems()
{
$user = \Phake::mock(User::clazz());
\Phake::when($user)->getId()->thenReturn('foo-id');
$token = \Phake::mock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\UsernamePasswordToken');
\Phake::when($token)->getUser()->thenReturn($user);
$tokenStorage = \Phake::mock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\Storage\\TokenStorageInterface');
\Phake::when($tokenStorage)->getToken()->thenReturn($token);
$configEntry = \Phake::mock('Modera\\ConfigBundle\\Config\\ConfigurationEntryInterface');
\Phake::when($configEntry)->getValue()->thenReturn('foo-value');
$configEntriesManager = \Phake::mock('Modera\\ConfigBundle\\Config\\ConfigurationEntriesManagerInterface');
\Phake::when($configEntriesManager)->findOneByNameOrDie(ModeraBackendGoogleAnalyticsBundle::TRACKING_CODE_CONFIG_KEY)->thenReturn($configEntry);
$provider = new ConfigMergersProvider($tokenStorage, $configEntriesManager, 'prod');
$items = $provider->getItems();
$this->assertTrue(is_array($items));
$this->assertEquals(1, count($items));
/* @var ConfigMergerInterface $merger */
$merger = $items[0];
$this->assertInstanceOf('Modera\\MjrIntegrationBundle\\Config\\ConfigMergerInterface', $merger);
$config = $merger->merge(array());
$this->assertArrayHasKey('modera_backend_google_analytics', $config);
$config = $config['modera_backend_google_analytics'];
$this->assertArrayHasKey('tracking_code', $config);
$this->assertEquals('foo-value', $config['tracking_code']);
$this->assertEquals('foo-id', $config['user_id']);
$this->assertArrayHasKey('user_id', $config);
$this->assertArrayHasKey('is_debug', $config);
$this->assertFalse($config['is_debug']);
// because it's "prod" env now
$this->assertArrayHasKey('prefix', $config);
$this->assertEquals('/backend', $config['prefix']);
// --- env = dev
$provider = new ConfigMergersProvider($tokenStorage, $configEntriesManager, 'dev');
$items = $provider->getItems();
$this->assertTrue(is_array($items));
$this->assertEquals(1, count($items));
$config = $items[0]->merge(array());
$this->assertTrue($config['modera_backend_google_analytics']['is_debug']);
}
/**
* First settings entries returned are more specific.
*
* @param User $user
*
* @return array
*/
private function getSettings(User $user)
{
$settings = [];
/** @var UserSettings $userSettings */
$userSettings = $this->em->getRepository(UserSettings::class)->findOneBy(array('user' => $user));
if ($userSettings) {
$settings[] = $userSettings->getDashboardSettings();
}
foreach ($user->getGroups() as $group) {
/** @var GroupSettings $groupSettings */
$groupSettings = $this->em->getRepository(GroupSettings::class)->findOneBy(array('group' => $group));
if ($groupSettings) {
$settings[] = $groupSettings->getDashboardSettings();
}
}
return $settings;
}
/**
* Find users by some property.
*
* @param $property
* @param $value
*
* @return User[]
*/
public function findUsersBy($property, $value)
{
return $this->em->getRepository(User::clazz())->findBy(array($property => $value));
}
/**
* @param User $user
*
* @return array
*/
public static function userToArray(User $user)
{
return array('id' => $user->getId(), 'name' => $user->getFullName(), 'email' => $user->getEmail(), 'username' => $user->getUsername());
}
/**
* @return array
*/
public function getConfig()
{
$self = $this;
return array('entity' => User::clazz(), 'create_default_data_mapper' => function (ContainerInterface $container) {
return $this->container->get('modera_backend_security.data_mapper.user_data_mapper');
}, 'security' => array('actions' => array('create' => ModeraBackendSecurityBundle::ROLE_MANAGE_USER_PROFILES, 'update' => function (AuthorizationCheckerInterface $ac, array $params) use($self) {
/* @var TokenStorageInterface $ts */
$ts = $self->get('security.token_storage');
/* @var User $user */
$user = $ts->getToken()->getUser();
if ($ac->isGranted(ModeraBackendSecurityBundle::ROLE_MANAGE_USER_PROFILES)) {
return true;
} else {
// irrespectively of what privileges user has we will always allow him to edit his
// own profile data
return $user instanceof User && isset($params['record']['id']) && $user->getId() == $params['record']['id'];
}
}, 'remove' => ModeraBackendSecurityBundle::ROLE_MANAGE_USER_PROFILES, 'list' => ModeraBackendSecurityBundle::ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION)), 'hydration' => array('groups' => array('main-form' => ['id', 'username', 'email', 'firstName', 'lastName', 'middleName', 'meta'], 'list' => function (User $user) {
$groups = array();
foreach ($user->getGroups() as $group) {
$groups[] = $group->getName();
}
return array('id' => $user->getId(), 'username' => $user->getUsername(), 'email' => $user->getEmail(), 'firstName' => $user->getFirstName(), 'lastName' => $user->getLastName(), 'middleName' => $user->getMiddleName(), 'state' => $user->getState(), 'groups' => $groups, 'meta' => $user->getMeta());
}, 'compact-list' => ['id', 'username', 'fullname'], 'delete-user' => ['username']), 'profiles' => array('list', 'delete-user', 'main-form', 'compact-list', 'modera-backend-security-group-groupusers' => HydrationProfile::create(false)->useGroups(array('compact-list')))), 'map_data_on_create' => function (array $params, User $entity, DataMapperInterface $defaultMapper, ContainerInterface $container) use($self) {
$defaultMapper->mapData($params, $entity);
if (isset($params['plainPassword']) && $params['plainPassword']) {
$plainPassword = $params['plainPassword'];
} else {
$plainPassword = $self->generatePassword();
}
$self->setPassword($entity, $plainPassword);
if (isset($params['sendPassword']) && $params['sendPassword'] != '') {
/* @var MailService $mailService */
$mailService = $container->get('modera_backend_security.service.mail_service');
$mailService->sendPassword($entity, $plainPassword);
}
}, 'map_data_on_update' => function (array $params, User $entity, DataMapperInterface $defaultMapper, ContainerInterface $container) use($self) {
$defaultMapper->mapData($params, $entity);
/* @var LoggerInterface $activityMgr */
$activityMgr = $container->get('modera_activity_logger.manager.activity_manager');
/* @var TokenStorageInterface $ts */
$ts = $container->get('security.token_storage');
if (isset($params['plainPassword']) && $params['plainPassword']) {
$self->setPassword($entity, $params['plainPassword']);
if (isset($params['sendPassword']) && $params['sendPassword'] != '') {
/* @var MailService $mailService */
$mailService = $container->get('modera_backend_security.service.mail_service');
$mailService->sendPassword($entity, $params['plainPassword']);
}
$activityMsg = T::trans('Password has been changed for user "%user%".', array('%user%' => $entity->getUsername()));
$activityContext = array('type' => 'user.password_changed', 'author' => $ts->getToken()->getUser()->getId());
$activityMgr->info($activityMsg, $activityContext);
} else {
$activityMsg = T::trans('Profile data is changed for user "%user%".', array('%user%' => $entity->getUsername()));
$activityContext = array('type' => 'user.profile_updated', 'author' => $ts->getToken()->getUser()->getId());
$activityMgr->info($activityMsg, $activityContext);
}
}, 'remove_entities_handler' => function ($entities, $params, $defaultHandler, ContainerInterface $container) {
/* @var UserService $userService */
$userService = $container->get('modera_security.service.user_service');
$operationResult = new OperationResult();
foreach ($entities as $entity) {
/* @var User $entity*/
$userService->remove($entity);
$operationResult->reportEntity(User::clazz(), $entity->getId(), OperationResult::TYPE_ENTITY_REMOVED);
}
return $operationResult;
});
}
/**
* @return array
*/
private static function getTablesClasses()
{
return array(Permission::clazz(), PermissionCategory::clazz(), User::clazz(), Group::clazz(), Activity::clazz());
}
/**
* {@inheritdoc}
*/
public function getUser()
{
return $this->em->getRepository(User::clazz())->findOneBy($this->config['query']);
}
