/** * Creates a user and returns it. * * @param string $username * @param string $password * @param string $email * @param bool $active * @param bool $superadmin * * @return \FOS\UserBundle\Model\UserInterface */ public function create($username, $password, $email, $active, $superadmin) { $discriminator = $this->discriminator; switch ($this->type) { case 'staff': $class = 'Truckee\\MatchBundle\\Entity\\Staff'; break; case 'admin': $class = 'Truckee\\MatchBundle\\Entity\\Admin'; break; case 'volunteer': $class = 'Truckee\\MatchBundle\\Entity\\Volunteer'; break; default: break; } $discriminator->setClass($class); $user = $this->userManager->createUser(); $user->setUsername($username); $user->setFirstname($this->firstname); $user->setLastname($this->lastname); $user->setEmail($email); $user->setPlainPassword($password); $user->setEnabled((bool) $active); $this->userManager->updateUser($user, true); return $user; }
public function postBind(DataEvent $event) { $user = $event->getForm()->getData(); if ($user instanceof UserInterface) { $this->userManager->updateCanonicalFields($user); } }
public function __invoke(Request $request) { if ($this->container->hasParameter('partkeepr.auth.allow_password_change') && $this->container->getParameter('partkeepr.auth.allow_password_change') === false) { throw new PasswordChangeNotAllowedException(); } $user = $this->userService->getUser(); if (!$request->request->has('oldpassword') && !$request->request->has('newpassword')) { throw new \Exception('old password and new password need to be specified'); } $FOSUser = $this->userManager->findUserByUsername($user->getUsername()); if ($FOSUser !== null) { $encoder = $this->encoderFactory->getEncoder($FOSUser); $encoded_pass = $encoder->encodePassword($request->request->get('oldpassword'), $FOSUser->getSalt()); if ($FOSUser->getPassword() != $encoded_pass) { throw new OldPasswordWrongException(); } $this->userManipulator->changePassword($user->getUsername(), $request->request->get('newpassword')); } else { if ($user->isLegacy()) { if ($user->getPassword() !== md5($request->request->get('oldpassword'))) { throw new OldPasswordWrongException(); } $user->setNewPassword($request->request->get('newpassword')); $this->userService->syncData($user); } else { throw new \Exception('Cannot change password for LDAP users'); } } $user->setPassword(''); $user->setNewPassword(''); return $user; }
/** * @param UserInterface $user */ protected function onSuccess(UserInterface $user) { if ($this->getNewPassword() != "") { $user->setPlainPassword($this->getNewPassword()); } $this->userManager->updateUser($user); }
/** * This must be called on prePersist and preUpdate if the event is about a * user. * * @param UserInterface $user */ protected function updateUserFields(UserInterface $user) { if (null === $this->userManager) { $this->userManager = $this->container->get('fos_user.user_manager'); } $this->userManager->updateCanonicalFields($user); $this->userManager->updatePassword($user); }
/** * Finds a user by his username and throws an exception if we can't find it. * * @param string $username * * @throws \InvalidArgumentException When user does not exist * * @return UserInterface */ private function findUserByUsernameOrThrowException($username) { $user = $this->userManager->findUserByUsername($username); if (!$user) { throw new \InvalidArgumentException(sprintf('User identified by "%s" username does not exist.', $username)); } return $user; }
/** * Removes the given user object. * * @param DataEvent $event */ public function deleteObject(DataEvent $event) { $object = $event->getData(); if ($object instanceof UserInterface) { $this->userManager->deleteUser($object); $this->eventDispatcher->dispatch(Events::POST_DELETE, $event); $event->stopPropagation(); } }
/** * Create user from response * * @param UserResponseInterface $response * * @return User */ private function createUserFromResponse(UserResponseInterface $response) { /** @var User $user User */ $user = $this->userManager->createUser(); $user->setUsername($response->getUsername())->setFullName($response->getRealName())->setEmail($response->getEmail())->setEnabled(true)->setPlainPassword(uniqid())->setFacebookId($response->getUsername())->setFacebookAccessToken($response->getAccessToken()); $this->eventDispatcher->dispatch(AppEvents::FACEBOOK_USER_CONNECTED, new FacebookUserConnectedEvent($user)); $this->userManager->updateUser($user); return $user; }
public function getNbUnreadByUsername($username) { $nb = apc_fetch('nbm.' . $username); if (false === $nb) { $user = $this->userManager->findUserByUsername($username); $nb = $this->updateNbUnread($participant); } return $nb; }
/** * handle user Ip log to users table, after login, with security.interactive_login kernel event. * * @param InteractiveLoginEvent $event */ public function onSecurityInteractiveLogin(InteractiveLoginEvent $event) { $user = $event->getAuthenticationToken()->getUser(); if ($user instanceof UserInterface) { $ipAddress = $this->requestStack->getCurrentRequest()->server->get('REMOTE_ADDR'); $user->setLastloginClientIp($ipAddress); $this->userManager->updateUser($user); } }
protected function createModelInstance() { $message = parent::createModelInstance(); if ($to = $this->request->query->get('to')) { if ($recipient = $this->userManager->findUserByUsername($to)) { $message->setRecipient($recipient); } } return $message; }
/** * Transforms a username string into a UserInterface instance. * * @param string $value Username * * @return UserInterface the corresponding UserInterface instance * * @throws UnexpectedTypeException if the given value is not a string */ public function reverseTransform($value) { if (null === $value || '' === $value) { return null; } if (!is_string($value)) { throw new UnexpectedTypeException($value, 'string'); } return $this->userManager->findUserByUsername($value); }
/** * @param string $email * @param string $pw * @return \FOS\UserBundle\Model\UserInterface|null */ function getUserByEmailPw($email, $pw) { $result = null; if ($email && $pw) { $user = $this->_fosUserManager->findUserByEmail($email); if ($user && $this->isPasswordValid($user, $pw)) { $result = $user; } } return $result; }
/** * Checks if the passed value is valid. * * @param mixed $value The value that should be validated * @param Constraint $constraint The constrain for the validation * * @return Boolean Whether or not the value is valid * * @throws UnexpectedTypeException if $value is not instance of \FOS\UserBundle\Model\UserInterface */ public function isValid($value, Constraint $constraint) { if (!$value instanceof UserInterface) { throw new UnexpectedTypeException($value, 'FOS\\UserBundle\\Model\\UserInterface'); } if (!$this->userManager->validateUnique($value, $constraint)) { $this->setMessage($constraint->message, array('%property%' => $constraint->property)); return false; } return true; }
private function handleEvent(LifecycleEventArgs $args) { if (null === $this->userManager) { $this->userManager = $this->container->get('fos_user.user_manager'); } $entity = $args->getEntity(); if ($entity instanceof UserInterface) { $this->userManager->updateCanonicalFields($entity); $this->userManager->updatePassword($entity); } }
public function closeAccount(Response $response) { $user = $this->securityContext->getToken()->getUser(); $user->setEnabled(false); $this->userManager->updateUser($user); $cookieHandler = new CookieClearingLogoutHandler($this->request->cookies->all()); $cookieHandler->logout($this->request, $response, $this->securityContext->getToken()); $sessionHandler = new SessionLogoutHandler(); $sessionHandler->logout($this->request, $response, $this->securityContext->getToken()); $this->securityContext->setToken(null); }
/** * Creates a user and returns it. * * @param string $username * @param string $password * @param string $email * @param Boolean $active * @param Boolean $superadmin * * @return \FOS\UserBundle\Model\UserInterface */ public function create($username, $password, $email, $active, $superadmin) { $user = $this->userManager->createUser(); $user->setUsername($username); $user->setName($this->name); $user->setSurname($this->surname); $user->setEmail($email); $user->setPlainPassword($password); $user->setEnabled((bool) $active); $this->userManager->updateUser($user, true); return $user; }
private function techRegister($form, $request, \Symfony\Component\EventDispatcher\EventDispatcherInterface $dispatcher, \FOS\UserBundle\Model\UserManagerInterface $userManager, $user) { $event = new FormEvent($form, $request); $dispatcher->dispatch(FOSUserEvents::REGISTRATION_SUCCESS, $event); $userManager->updateUser($user); if (null === ($response = $event->getResponse())) { $url = $this->container->get('router')->generate('fos_user_registration_confirmed'); $response = new RedirectResponse($url); } $dispatcher->dispatch(FOSUserEvents::REGISTRATION_COMPLETED, new FilterUserResponseEvent($user, $request, $response)); return $response; }
/** * Creates a user and returns it. * * @param string $email * @param string $password * @param string $fullname * @param string $institution * @param bool $active * @param bool $superadmin * * @return User */ public function create($email, $password, $fullname, $institution, $active, $superadmin) { $user = $this->userManager->createUser(); $user->setEmail($email); $user->setPlainPassword($password); $user->setFullname($fullname); $user->setInstitution($institution); $user->setEnabled($active); $user->setSuperAdmin($superadmin); $this->userManager->updateUser($user); return $user; }
protected function onSuccess() { if ($this->confirmation) { $user->setEnabled(false); $this->mailer->sendConfirmationEmailMessage($this->user); } else { $user->setConfirmationToken(null); $user->setEnabled(true); } $user->setRoles(array('ROLE_ADMIN')); $user->setPermissions(array('VIEW', 'EDIT', 'CREATE', 'DELETE')); $this->userManager->updateUser($this->user, true); }
/** * @param HookInterface $apiService * @param string $entityName * @return mixed $entityName instance */ public function hydrate(HookInterface $apiService, $entityName) { $hydratedEntity = new $entityName(); if (!$hydratedEntity instanceof HookEventInterface) { throw new LogicException("Can't hydrate this event"); } $hydratedEntity->setEmail($apiService->getEmail()); $hydratedEntity->setName($apiService->getService()); $hydratedEntity->setMetaData($apiService->getMetaData()); $user = $this->userManager->findUserByEmail($apiService->getEmail()); $hydratedEntity->setUser($user); return $hydratedEntity; }
/** * {@inheritDoc} */ public function loadUserByOAuthUserResponse(UserResponseInterface $response) { $username = $response->getUsername(); /** @var User $user */ $user = $this->userManager->findUserBy(array('githubId' => $username)); if (!$user) { throw new AccountNotLinkedException(sprintf('No user with github username "%s" was found.', $username)); } if ($user->getGithubToken() !== $response->getAccessToken()) { $user->setGithubToken($response->getAccessToken()); $this->userManager->updateUser($user); } return $user; }
/** * Creates a user and returns it. * * @param string $username * @param string $password * @param string $email * @param Boolean $active * @param Boolean $superadmin * @param string $firstName * @param string $lastName * @param integer $phoneNumber * * @return \AppBundle\Entity\Users */ public function create($username, $password, $email, $active, $superadmin, $firstName, $lastName, $phoneNumber) { $user = new Users(); $user->setUsername($username); $user->setEmail($email); $user->setPlainPassword($password); $user->setEnabled((bool) $active); $user->setFirstName($firstName); $user->setLastName($lastName); $user->setPhoneNumber($phoneNumber); $user->setSuperAdmin((bool) $superadmin); $this->userManager->updateUser($user); return $user; }
/** * @param $email * @param $password * @return \FOS\UserBundle\Model\UserInterface * @throws ValidationException */ public function registerUser($email, $password) { $user = $this->userManager->createUser(); $user->setUsername($email); $user->setEmail($email); $user->setPlainPassword($password); $user->setEnabled(true); $errors = $this->validator->validate($user, null, array('registration')); if ($errors->count() > 0) { throw new ValidationException($errors); } $this->userManager->updateUser($user); return UserDTO::withEntity($user); }
/** * {@inheritDoc} */ public function connect($user, UserResponseInterface $response) { $property = $this->getProperty($response); $setter = 'set' . ucfirst($property); if (!method_exists($user, $setter)) { throw new \RuntimeException(sprintf("Class '%s' should have a method '%s'.", get_class($user), $setter)); } $username = $response->getUsername(); if (null !== ($previousUser = $this->userManager->findUserBy(array($property => $username)))) { $previousUser->{$setter}(null); $this->userManager->updateUser($previousUser); } $user->{$setter}($username); $this->userManager->updateUser($user); }
/** * Creates a user and returns it. * * @param string $username * @param string $password * @param string $email * @param string $name * @param string $lastName * @param bool $active * @param bool $superadmin * * @return \FOS\UserBundle\Model\UserInterface */ public function create($username, $password, $email, $name, $lastName, $active, $superadmin, $changePassword) { $user = $this->userManager->createUser(); $user->setUsername($username); $user->setEmail($email); $user->setPlainPassword($password); $user->setName($name); $user->setLastName($lastName); $user->setEnabled((bool) $active); $user->setSuperAdmin((bool) $superadmin); if ((bool) $changePassword) { $user->setPasswordExpireAt(new \DateTime()); } $this->userManager->updateUser($user); return $user; }
public function unlock(User $user, $username, $password) { $user->setUsername($username); $user->setPlainPassword($password); $user->setUnlockToken(null); $errors = $this->validator->validate($user, ['Registration']); if ($errors->count() === 0) { try { $this->userManager->updateUser($user); } catch (\Exception $e) { throw new Exception($e->getMessage()); } return true; } return $errors; }
/** * Create user from response * * @param UserResponseInterface $response * * @return User */ private function createUserFromResponse(UserResponseInterface $response) { $email = $response->getEmail() ?: $response->getUsername() . '@example.com'; /** @var User $user */ $user = $this->userManager->createUser(); $user->setEmail($email); $user->setUsername($response->getNickname()); $user->setEnabled(true); $user->setPlainPassword(uniqid()); $user->setGithubId($response->getUsername()); // Move to separate listener if (in_array($response->getUsername(), $this->adminGitHubIds)) { $user->addRole('ROLE_ADMIN'); } $this->userManager->updateUser($user); return $user; }
/** * Persists, updates or delete data return by the controller if applicable. * * @param GetResponseForControllerResultEvent $event */ public function onKernelView(GetResponseForControllerResultEvent $event) { $user = $event->getControllerResult(); if (!$user instanceof UserInterface) { return; } switch ($event->getRequest()->getMethod()) { case Request::METHOD_POST: case Request::METHOD_PUT: $this->userManager->updateUser($user, false); break; case Request::METHOD_DELETE: $this->userManager->deleteUser($user); $event->setControllerResult(null); break; } }
/** * @covers Ingewikkeld\Rest\UserBundle\ResourceMapper\User::delete */ public function testDeleteUserFromDatabase() { $resourceMock = m::mock('Hal\\Resource')->shouldReceive('toArray')->andReturn(array('username' => self::TEST_USERNAME))->getMock(); $user = $this->createUserMock(self::TEST_USERNAME, self::TEST_EMAIL, null); $this->userManagerMock->shouldReceive('findUserByUsername')->with(self::TEST_USERNAME)->andReturn($user); $this->userManagerMock->shouldReceive('deleteUser')->with($user); $this->fixture->delete($resourceMock); }